diff --git a/crypto/smartcont/tolk-stdlib/common.tolk b/crypto/smartcont/tolk-stdlib/common.tolk
index dec12e233..46068a206 100644
--- a/crypto/smartcont/tolk-stdlib/common.tolk
+++ b/crypto/smartcont/tolk-stdlib/common.tolk
@@ -1,7 +1,7 @@
// Standard library for Tolk (LGPL licence).
// It contains common functions that are available out of the box, the user doesn't have to import anything.
// More specific functions are required to be imported explicitly, like "@stdlib/tvm-dicts".
-tolk 0.6
+tolk 0.7
/**
Tuple manipulation primitives.
@@ -17,17 +17,17 @@ fun createEmptyTuple(): tuple
/// Appends a value to tuple, resulting in `Tuple t' = (x1, ..., xn, value)`.
/// If its size exceeds 255, throws a type check exception.
@pure
-fun tuplePush<X>(mutate self: tuple, value: X): void
+fun tuplePush<T>(mutate self: tuple, value: T): void
asm "TPUSH";
/// Returns the first element of a non-empty tuple.
@pure
-fun tupleFirst<X>(t: tuple): X
+fun tupleFirst<T>(t: tuple): T
asm "FIRST";
/// Returns the [`index`]-th element of a tuple.
@pure
-fun tupleAt<X>(t: tuple, index: int): X
+fun tupleAt<T>(t: tuple, index: int): T
builtin;
/// Returns the size of a tuple (elements count in it).
@@ -37,7 +37,7 @@ fun tupleSize(t: tuple): int
/// Returns the last element of a non-empty tuple.
@pure
-fun tupleLast(t: tuple): int
+fun tupleLast<T>(t: tuple): T
asm "LAST";
@@ -205,7 +205,7 @@ fun stringHash(s: slice): int
/// That is, if [hash] is computed as the hash of some data, these data are hashed twice,
/// the second hashing occurring inside `CHKSIGNS`.
@pure
-fun isSignatureValid(hash: int, signature: slice, publicKey: int): int
+fun isSignatureValid(hash: int, signature: slice, publicKey: int): bool
asm "CHKSIGNU";
/// Checks whether [signature] is a valid Ed25519-signature of the data portion of `slice data` using `publicKey`,
@@ -214,7 +214,7 @@ fun isSignatureValid(hash: int, signature: slice, publicKey: int): int
/// The verification of Ed25519 signatures is the standard one,
/// with sha256 used to reduce [data] to the 256-bit number that is actually signed.
@pure
-fun isSliceSignatureValid(data: slice, signature: slice, publicKey: int): int
+fun isSliceSignatureValid(data: slice, signature: slice, publicKey: int): bool
asm "CHKSIGNS";
/// Generates a new pseudo-random unsigned 256-bit integer x.
@@ -259,14 +259,14 @@ fun randomizeByLogicalTime(): void
/// otherwise the computation is aborted before visiting the `(maxCells + 1)`-st cell and
/// a zero flag is returned to indicate failure. If [c] is `null`, returns `x = y = z = 0`.
@pure
-fun calculateCellSize(c: cell, maxCells: int): (int, int, int, int)
+fun calculateCellSize(c: cell, maxCells: int): (int, int, int, bool)
asm "CDATASIZEQ NULLSWAPIFNOT2 NULLSWAPIFNOT";
/// Similar to [calculateCellSize], but accepting a `slice` [s] instead of a `cell`.
/// The returned value of `x` does not take into account the cell that contains the `slice` [s] itself;
/// however, the data bits and the cell references of [s] are accounted for in `y` and `z`.
@pure
-fun calculateSliceSize(s: slice, maxCells: int): (int, int, int, int)
+fun calculateSliceSize(s: slice, maxCells: int): (int, int, int, bool)
asm "SDATASIZEQ NULLSWAPIFNOT2 NULLSWAPIFNOT";
/// A non-quiet version of [calculateCellSize] that throws a cell overflow exception (`8`) on failure.
@@ -306,11 +306,11 @@ fun getBuilderDepth(b: builder): int
*/
/// Dump a variable [x] to the debug log.
-fun debugPrint<X>(x: X): void
+fun debugPrint<T>(x: T): void
builtin;
/// Dump a string [x] to the debug log.
-fun debugPrintString<X>(x: X): void
+fun debugPrintString<T>(x: T): void
builtin;
/// Dumps the stack (at most the top 255 values) and shows the total stack depth.
@@ -382,7 +382,7 @@ fun loadCoins(mutate self: slice): int
/// Loads bool (-1 or 0) from a slice
@pure
-fun loadBool(mutate self: slice): int
+fun loadBool(mutate self: slice): bool
asm( -> 1 0) "1 LDI";
/// Shifts a slice pointer to [len] bits forward, mutating the slice.
@@ -482,7 +482,7 @@ fun storeCoins(mutate self: builder, x: int): self
/// Stores bool (-1 or 0) into a builder.
/// Attention: true value is `-1`, not 1! If you pass `1` here, TVM will throw an exception.
@pure
-fun storeBool(mutate self: builder, x: int): self
+fun storeBool(mutate self: builder, x: bool): self
asm(x self) "1 STI";
/// Stores dictionary (represented by TVM `cell` or `null`) into a builder.
@@ -529,22 +529,22 @@ fun getRemainingBitsAndRefsCount(self: slice): (int, int)
/// Checks whether a slice is empty (i.e., contains no bits of data and no cell references).
@pure
-fun isEndOfSlice(self: slice): int
+fun isEndOfSlice(self: slice): bool
asm "SEMPTY";
/// Checks whether a slice has no bits of data.
@pure
-fun isEndOfSliceBits(self: slice): int
+fun isEndOfSliceBits(self: slice): bool
asm "SDEMPTY";
/// Checks whether a slice has no references.
@pure
-fun isEndOfSliceRefs(self: slice): int
+fun isEndOfSliceRefs(self: slice): bool
asm "SREMPTY";
/// Checks whether data parts of two slices coinside.
@pure
-fun isSliceBitsEqual(self: slice, b: slice): int
+fun isSliceBitsEqual(self: slice, b: slice): bool
asm "SDEQ";
/// Returns the number of cell references already stored in a builder.
@@ -621,10 +621,10 @@ fun parseStandardAddress(s: slice): (int, int)
fun createAddressNone(): slice
asm "b{00} PUSHSLICE";
-/// Returns if a slice pointer contains an empty address (`-1` for true, `0` for false, as always).
+/// Returns if a slice pointer contains an empty address.
/// In other words, a slice starts with two `0` bits (TL addr_none$00).
@pure
-fun addressIsNone(s: slice): int
+fun addressIsNone(s: slice): bool
asm "2 PLDU" "0 EQINT";
@@ -677,8 +677,8 @@ fun loadMessageFlags(mutate self: slice): int
/// Having msgFlags (4 bits), check that a message is bounced.
/// Effectively, it's `msgFlags & 1` (the lowest bit present).
@pure
-fun isMessageBounced(msgFlags: int): int
- asm "1 PUSHINT" "AND";
+fun isMessageBounced(msgFlags: int): bool
+ asm "2 PUSHINT" "MODR";
/// Skip 0xFFFFFFFF prefix (when a message is bounced).
@pure
diff --git a/crypto/smartcont/tolk-stdlib/gas-payments.tolk b/crypto/smartcont/tolk-stdlib/gas-payments.tolk
index 1dc6f3f89..83893354d 100644
--- a/crypto/smartcont/tolk-stdlib/gas-payments.tolk
+++ b/crypto/smartcont/tolk-stdlib/gas-payments.tolk
@@ -1,5 +1,5 @@
// A part of standard library for Tolk
-tolk 0.6
+tolk 0.7
/**
Gas and payment related primitives.
@@ -61,3 +61,9 @@ fun calculateOriginalMessageFee(workchain: int, incomingFwdFee: int): int
/// If it has no debt, `0` is returned.
fun getMyStorageDuePayment(): int
asm "DUEPAYMENT";
+
+/// Returns the amount of nanotoncoins charged for storage.
+/// (during storage phase preceeding to current computation phase)
+@pure
+fun getMyStoragePaidPayment(): int
+ asm "STORAGEFEES";
diff --git a/crypto/smartcont/tolk-stdlib/lisp-lists.tolk b/crypto/smartcont/tolk-stdlib/lisp-lists.tolk
index f7a721918..429f0cbfd 100644
--- a/crypto/smartcont/tolk-stdlib/lisp-lists.tolk
+++ b/crypto/smartcont/tolk-stdlib/lisp-lists.tolk
@@ -1,5 +1,5 @@
// A part of standard library for Tolk
-tolk 0.6
+tolk 0.7
/**
Lisp-style lists are nested 2-elements tuples: `(1, (2, (3, null)))` represents list `[1, 2, 3]`.
diff --git a/crypto/smartcont/tolk-stdlib/tvm-dicts.tolk b/crypto/smartcont/tolk-stdlib/tvm-dicts.tolk
index 9fba24d90..a47fe5426 100644
--- a/crypto/smartcont/tolk-stdlib/tvm-dicts.tolk
+++ b/crypto/smartcont/tolk-stdlib/tvm-dicts.tolk
@@ -1,5 +1,5 @@
// A part of standard library for Tolk
-tolk 0.6
+tolk 0.7
/**
Dictionaries are represented as `cell` data type (cells can store anything, dicts in particular).
@@ -19,20 +19,20 @@ fun createEmptyDict(): cell
/// Checks whether a dictionary is empty.
@pure
-fun dictIsEmpty(self: cell): int
+fun dictIsEmpty(self: cell): bool
asm "DICTEMPTY";
@pure
-fun iDictGet(self: cell, keyLen: int, key: int): (slice, int)
+fun iDictGet(self: cell, keyLen: int, key: int): (slice, bool)
asm(key self keyLen) "DICTIGET" "NULLSWAPIFNOT";
@pure
-fun uDictGet(self: cell, keyLen: int, key: int): (slice, int)
+fun uDictGet(self: cell, keyLen: int, key: int): (slice, bool)
asm(key self keyLen) "DICTUGET" "NULLSWAPIFNOT";
@pure
-fun sDictGet(self: cell, keyLen: int, key: slice): (slice, int)
+fun sDictGet(self: cell, keyLen: int, key: slice): (slice, bool)
asm(key self keyLen) "DICTGET" "NULLSWAPIFNOT";
@@ -63,33 +63,33 @@ fun sDictSetRef(mutate self: cell, keyLen: int, key: slice, value: cell): void
@pure
-fun iDictSetIfNotExists(mutate self: cell, keyLen: int, key: int, value: slice): int
+fun iDictSetIfNotExists(mutate self: cell, keyLen: int, key: int, value: slice): bool
asm(value key self keyLen) "DICTIADD";
@pure
-fun uDictSetIfNotExists(mutate self: cell, keyLen: int, key: int, value: slice): int
+fun uDictSetIfNotExists(mutate self: cell, keyLen: int, key: int, value: slice): bool
asm(value key self keyLen) "DICTUADD";
@pure
-fun iDictSetIfExists(mutate self: cell, keyLen: int, key: int, value: slice): int
+fun iDictSetIfExists(mutate self: cell, keyLen: int, key: int, value: slice): bool
asm(value key self keyLen) "DICTIREPLACE";
@pure
-fun uDictSetIfExists(mutate self: cell, keyLen: int, key: int, value: slice): int
+fun uDictSetIfExists(mutate self: cell, keyLen: int, key: int, value: slice): bool
asm(value key self keyLen) "DICTUREPLACE";
@pure
-fun iDictGetRef(self: cell, keyLen: int, key: int): (cell, int)
+fun iDictGetRef(self: cell, keyLen: int, key: int): (cell, bool)
asm(key self keyLen) "DICTIGETREF" "NULLSWAPIFNOT";
@pure
-fun uDictGetRef(self: cell, keyLen: int, key: int): (cell, int)
+fun uDictGetRef(self: cell, keyLen: int, key: int): (cell, bool)
asm(key self keyLen) "DICTUGETREF" "NULLSWAPIFNOT";
@pure
-fun sDictGetRef(self: cell, keyLen: int, key: slice): (cell, int)
+fun sDictGetRef(self: cell, keyLen: int, key: slice): (cell, bool)
asm(key self keyLen) "DICTGETREF" "NULLSWAPIFNOT";
@@ -107,28 +107,28 @@ fun sDictGetRefOrNull(self: cell, keyLen: int, key: slice): cell
@pure
-fun iDictDelete(mutate self: cell, keyLen: int, key: int): int
+fun iDictDelete(mutate self: cell, keyLen: int, key: int): bool
asm(key self keyLen) "DICTIDEL";
@pure
-fun uDictDelete(mutate self: cell, keyLen: int, key: int): int
+fun uDictDelete(mutate self: cell, keyLen: int, key: int): bool
asm(key self keyLen) "DICTUDEL";
@pure
-fun sDictDelete(mutate self: cell, keyLen: int, key: slice): int
+fun sDictDelete(mutate self: cell, keyLen: int, key: slice): bool
asm(key self keyLen) "DICTDEL";
@pure
-fun iDictSetAndGet(mutate self: cell, keyLen: int, key: int, value: slice): (slice, int)
+fun iDictSetAndGet(mutate self: cell, keyLen: int, key: int, value: slice): (slice, bool)
asm(value key self keyLen) "DICTISETGET" "NULLSWAPIFNOT";
@pure
-fun uDictSetAndGet(mutate self: cell, keyLen: int, key: int, value: slice): (slice, int)
+fun uDictSetAndGet(mutate self: cell, keyLen: int, key: int, value: slice): (slice, bool)
asm(value key self keyLen) "DICTUSETGET" "NULLSWAPIFNOT";
@pure
-fun sDictSetAndGet(mutate self: cell, keyLen: int, key: slice, value: slice): (slice, int)
+fun sDictSetAndGet(mutate self: cell, keyLen: int, key: slice, value: slice): (slice, bool)
asm(value key self keyLen) "DICTSETGET" "NULLSWAPIFNOT";
@@ -142,15 +142,15 @@ fun uDictSetAndGetRefOrNull(mutate self: cell, keyLen: int, key: int, value: cel
@pure
-fun iDictDeleteAndGet(mutate self: cell, keyLen: int, key: int): (slice, int)
+fun iDictDeleteAndGet(mutate self: cell, keyLen: int, key: int): (slice, bool)
asm(key self keyLen) "DICTIDELGET" "NULLSWAPIFNOT";
@pure
-fun uDictDeleteAndGet(mutate self: cell, keyLen: int, key: int): (slice, int)
+fun uDictDeleteAndGet(mutate self: cell, keyLen: int, key: int): (slice, bool)
asm(key self keyLen) "DICTUDELGET" "NULLSWAPIFNOT";
@pure
-fun sDictDeleteAndGet(mutate self: cell, keyLen: int, key: slice): (slice, int)
+fun sDictDeleteAndGet(mutate self: cell, keyLen: int, key: slice): (slice, bool)
asm(key self keyLen) "DICTDELGET" "NULLSWAPIFNOT";
@@ -168,129 +168,129 @@ fun sDictSetBuilder(mutate self: cell, keyLen: int, key: slice, value: builder):
@pure
-fun iDictSetBuilderIfNotExists(mutate self: cell, keyLen: int, key: int, value: builder): int
+fun iDictSetBuilderIfNotExists(mutate self: cell, keyLen: int, key: int, value: builder): bool
asm(value key self keyLen) "DICTIADDB";
@pure
-fun uDictSetBuilderIfNotExists(mutate self: cell, keyLen: int, key: int, value: builder): int
+fun uDictSetBuilderIfNotExists(mutate self: cell, keyLen: int, key: int, value: builder): bool
asm(value key self keyLen) "DICTUADDB";
@pure
-fun iDictSetBuilderIfExists(mutate self: cell, keyLen: int, key: int, value: builder): int
+fun iDictSetBuilderIfExists(mutate self: cell, keyLen: int, key: int, value: builder): bool
asm(value key self keyLen) "DICTIREPLACEB";
@pure
-fun uDictSetBuilderIfExists(mutate self: cell, keyLen: int, key: int, value: builder): int
+fun uDictSetBuilderIfExists(mutate self: cell, keyLen: int, key: int, value: builder): bool
asm(value key self keyLen) "DICTUREPLACEB";
@pure
-fun iDictDeleteFirstAndGet(mutate self: cell, keyLen: int): (int, slice, int)
+fun iDictDeleteFirstAndGet(mutate self: cell, keyLen: int): (int, slice, bool)
asm(-> 0 2 1 3) "DICTIREMMIN" "NULLSWAPIFNOT2";
@pure
-fun uDictDeleteFirstAndGet(mutate self: cell, keyLen: int): (int, slice, int)
+fun uDictDeleteFirstAndGet(mutate self: cell, keyLen: int): (int, slice, bool)
asm(-> 0 2 1 3) "DICTUREMMIN" "NULLSWAPIFNOT2";
@pure
-fun sDictDeleteFirstAndGet(mutate self: cell, keyLen: int): (slice, slice, int)
+fun sDictDeleteFirstAndGet(mutate self: cell, keyLen: int): (slice, slice, bool)
asm(-> 0 2 1 3) "DICTREMMIN" "NULLSWAPIFNOT2";
@pure
-fun iDictDeleteLastAndGet(mutate self: cell, keyLen: int): (int, slice, int)
+fun iDictDeleteLastAndGet(mutate self: cell, keyLen: int): (int, slice, bool)
asm(-> 0 2 1 3) "DICTIREMMAX" "NULLSWAPIFNOT2";
@pure
-fun uDictDeleteLastAndGet(mutate self: cell, keyLen: int): (int, slice, int)
+fun uDictDeleteLastAndGet(mutate self: cell, keyLen: int): (int, slice, bool)
asm(-> 0 2 1 3) "DICTUREMMAX" "NULLSWAPIFNOT2";
@pure
-fun sDictDeleteLastAndGet(mutate self: cell, keyLen: int): (slice, slice, int)
+fun sDictDeleteLastAndGet(mutate self: cell, keyLen: int): (slice, slice, bool)
asm(-> 0 2 1 3) "DICTREMMAX" "NULLSWAPIFNOT2";
@pure
-fun iDictGetFirst(self: cell, keyLen: int): (int, slice, int)
+fun iDictGetFirst(self: cell, keyLen: int): (int, slice, bool)
asm (-> 1 0 2) "DICTIMIN" "NULLSWAPIFNOT2";
@pure
-fun uDictGetFirst(self: cell, keyLen: int): (int, slice, int)
+fun uDictGetFirst(self: cell, keyLen: int): (int, slice, bool)
asm (-> 1 0 2) "DICTUMIN" "NULLSWAPIFNOT2";
@pure
-fun sDictGetFirst(self: cell, keyLen: int): (slice, slice, int)
+fun sDictGetFirst(self: cell, keyLen: int): (slice, slice, bool)
asm (-> 1 0 2) "DICTMIN" "NULLSWAPIFNOT2";
@pure
-fun iDictGetFirstAsRef(self: cell, keyLen: int): (int, cell, int)
+fun iDictGetFirstAsRef(self: cell, keyLen: int): (int, cell, bool)
asm (-> 1 0 2) "DICTIMINREF" "NULLSWAPIFNOT2";
@pure
-fun uDictGetFirstAsRef(self: cell, keyLen: int): (int, cell, int)
+fun uDictGetFirstAsRef(self: cell, keyLen: int): (int, cell, bool)
asm (-> 1 0 2) "DICTUMINREF" "NULLSWAPIFNOT2";
@pure
-fun sDictGetFirstAsRef(self: cell, keyLen: int): (slice, cell, int)
+fun sDictGetFirstAsRef(self: cell, keyLen: int): (slice, cell, bool)
asm (-> 1 0 2) "DICTMINREF" "NULLSWAPIFNOT2";
@pure
-fun iDictGetLast(self: cell, keyLen: int): (int, slice, int)
+fun iDictGetLast(self: cell, keyLen: int): (int, slice, bool)
asm (-> 1 0 2) "DICTIMAX" "NULLSWAPIFNOT2";
@pure
-fun uDictGetLast(self: cell, keyLen: int): (int, slice, int)
+fun uDictGetLast(self: cell, keyLen: int): (int, slice, bool)
asm (-> 1 0 2) "DICTUMAX" "NULLSWAPIFNOT2";
@pure
-fun sDictGetLast(self: cell, keyLen: int): (slice, slice, int)
+fun sDictGetLast(self: cell, keyLen: int): (slice, slice, bool)
asm (-> 1 0 2) "DICTMAX" "NULLSWAPIFNOT2";
@pure
-fun iDictGetLastAsRef(self: cell, keyLen: int): (int, cell, int)
+fun iDictGetLastAsRef(self: cell, keyLen: int): (int, cell, bool)
asm (-> 1 0 2) "DICTIMAXREF" "NULLSWAPIFNOT2";
@pure
-fun uDictGetLastAsRef(self: cell, keyLen: int): (int, cell, int)
+fun uDictGetLastAsRef(self: cell, keyLen: int): (int, cell, bool)
asm (-> 1 0 2) "DICTUMAXREF" "NULLSWAPIFNOT2";
@pure
-fun sDictGetLastAsRef(self: cell, keyLen: int): (slice, cell, int)
+fun sDictGetLastAsRef(self: cell, keyLen: int): (slice, cell, bool)
asm (-> 1 0 2) "DICTMAXREF" "NULLSWAPIFNOT2";
@pure
-fun iDictGetNext(self: cell, keyLen: int, pivot: int): (int, slice, int)
+fun iDictGetNext(self: cell, keyLen: int, pivot: int): (int, slice, bool)
asm(pivot self keyLen -> 1 0 2) "DICTIGETNEXT" "NULLSWAPIFNOT2";
@pure
-fun uDictGetNext(self: cell, keyLen: int, pivot: int): (int, slice, int)
+fun uDictGetNext(self: cell, keyLen: int, pivot: int): (int, slice, bool)
asm(pivot self keyLen -> 1 0 2) "DICTUGETNEXT" "NULLSWAPIFNOT2";
@pure
-fun iDictGetNextOrEqual(self: cell, keyLen: int, pivot: int): (int, slice, int)
+fun iDictGetNextOrEqual(self: cell, keyLen: int, pivot: int): (int, slice, bool)
asm(pivot self keyLen -> 1 0 2) "DICTIGETNEXTEQ" "NULLSWAPIFNOT2";
@pure
-fun uDictGetNextOrEqual(self: cell, keyLen: int, pivot: int): (int, slice, int)
+fun uDictGetNextOrEqual(self: cell, keyLen: int, pivot: int): (int, slice, bool)
asm(pivot self keyLen -> 1 0 2) "DICTUGETNEXTEQ" "NULLSWAPIFNOT2";
@pure
-fun iDictGetPrev(self: cell, keyLen: int, pivot: int): (int, slice, int)
+fun iDictGetPrev(self: cell, keyLen: int, pivot: int): (int, slice, bool)
asm(pivot self keyLen -> 1 0 2) "DICTIGETPREV" "NULLSWAPIFNOT2";
@pure
-fun uDictGetPrev(self: cell, keyLen: int, pivot: int): (int, slice, int)
+fun uDictGetPrev(self: cell, keyLen: int, pivot: int): (int, slice, bool)
asm(pivot self keyLen -> 1 0 2) "DICTUGETPREV" "NULLSWAPIFNOT2";
@pure
-fun iDictGetPrevOrEqual(self: cell, keyLen: int, pivot: int): (int, slice, int)
+fun iDictGetPrevOrEqual(self: cell, keyLen: int, pivot: int): (int, slice, bool)
asm(pivot self keyLen -> 1 0 2) "DICTIGETPREVEQ" "NULLSWAPIFNOT2";
@pure
-fun uDictGetPrevOrEqual(self: cell, keyLen: int, pivot: int): (int, slice, int)
+fun uDictGetPrevOrEqual(self: cell, keyLen: int, pivot: int): (int, slice, bool)
asm(pivot self keyLen -> 1 0 2) "DICTUGETPREVEQ" "NULLSWAPIFNOT2";
@@ -299,13 +299,13 @@ fun uDictGetPrevOrEqual(self: cell, keyLen: int, pivot: int): (int, slice, int)
*/
@pure
-fun prefixDictGet(self: cell, keyLen: int, key: slice): (slice, slice, slice, int)
+fun prefixDictGet(self: cell, keyLen: int, key: slice): (slice, slice, slice, bool)
asm(key self keyLen) "PFXDICTGETQ" "NULLSWAPIFNOT2";
@pure
-fun prefixDictSet(mutate self: cell, keyLen: int, key: slice, value: slice): int
+fun prefixDictSet(mutate self: cell, keyLen: int, key: slice, value: slice): bool
asm(value key self keyLen) "PFXDICTSET";
@pure
-fun prefixDictDelete(mutate self: cell, keyLen: int, key: slice): int
+fun prefixDictDelete(mutate self: cell, keyLen: int, key: slice): bool
asm(key self keyLen) "PFXDICTDEL";
diff --git a/crypto/smartcont/tolk-stdlib/tvm-lowlevel.tolk b/crypto/smartcont/tolk-stdlib/tvm-lowlevel.tolk
index 91b35f2bd..ef7c2afe9 100644
--- a/crypto/smartcont/tolk-stdlib/tvm-lowlevel.tolk
+++ b/crypto/smartcont/tolk-stdlib/tvm-lowlevel.tolk
@@ -1,5 +1,5 @@
// A part of standard library for Tolk
-tolk 0.6
+tolk 0.7
/// 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`.
diff --git a/tolk-tester/tests/a10.tolk b/tolk-tester/tests/a10.tolk
index d46397c6a..7301f1d50 100644
--- a/tolk-tester/tests/a10.tolk
+++ b/tolk-tester/tests/a10.tolk
@@ -35,7 +35,7 @@ fun test88(x: int) {
}
@method_id(89)
-fun test89(last: int) {
+fun test89(last: int): (int, int, int, int) {
var t: tuple = createEmptyTuple();
t.tuplePush(1);
t.tuplePush(2);
diff --git a/tolk-tester/tests/a6.tolk b/tolk-tester/tests/a6.tolk
index 7f2c39461..32fd3364c 100644
--- a/tolk-tester/tests/a6.tolk
+++ b/tolk-tester/tests/a6.tolk
@@ -9,6 +9,7 @@ fun calc_phi(): int {
repeat (70) { n*=10; };
var p= 1;
var `q`=1;
+ _=`q`;
do {
(p,q)=(q,p+q);
} while (q <= n); //;;
@@ -27,7 +28,7 @@ fun calc_sqrt2(): int {
return mulDivRound(p, n, q);
}
-fun calc_root(m: auto): auto {
+fun calc_root(m: int) {
var base: int=1;
repeat(70) { base *= 10; }
var (a, b, c) = (1,0,-m);
diff --git a/tolk-tester/tests/a6_5.tolk b/tolk-tester/tests/a6_5.tolk
index 8b300c0c9..43fd59c5a 100644
--- a/tolk-tester/tests/a6_5.tolk
+++ b/tolk-tester/tests/a6_5.tolk
@@ -1,5 +1,5 @@
@deprecated
-fun twice(f: auto, x: auto): auto {
+fun twice(f: int -> int, x: int) {
return f (f (x));
}
diff --git a/tolk-tester/tests/allow_post_modification.tolk b/tolk-tester/tests/allow_post_modification.tolk
index 5cfa2f3d8..e374f62b3 100644
--- a/tolk-tester/tests/allow_post_modification.tolk
+++ b/tolk-tester/tests/allow_post_modification.tolk
@@ -2,85 +2,112 @@ fun unsafe_tuple<X>(x: X): tuple
asm "NOP";
fun inc(x: int, y: int): (int, int) {
- return (x + y, y * 10);
+ return (x + y, y * 10);
}
fun `~inc`(mutate self: int, y: int): int {
- val (newX, newY) = inc(self, y);
- self = newX;
- return newY;
+ val (newX, newY) = inc(self, y);
+ self = newX;
+ return newY;
}
+fun eq<X>(v: X): X { return v; }
+fun eq2(v: (int, int)) { return v; }
+fun mul2(mutate dest: int, v: int): int { dest = v*2; return dest; }
+fun multens(mutate self: (int, int), v: (int, int)): (int, int) { var (f, s) = self; var (m1, m2) = v; self = (f*m1, s*m2); return self; }
+
@method_id(11)
fun test_return(x: int): (int, int, int, int, int, int, int) {
- return (x, x.`~inc`(x / 20), x, x = x * 2, x, x += 1, x);
+ return (x, x.`~inc`(x / 20), x, x = x * 2, x, x += 1, x);
}
@method_id(12)
fun test_assign(x: int): (int, int, int, int, int, int, int) {
- var (x1: int, x2: int, x3: int, x4: int, x5: int, x6: int, x7: int) = (x, x.`~inc`(x / 20), x, x=x*2, x, x+=1, x);
- return (x1, x2, x3, x4, x5, x6, x7);
+ var (x1: int, x2: int, x3: int, x4: int, x5: int, x6: int, x7: int) = (x, x.`~inc`(x / 20), x, x=x*2, x, x+=1, x);
+ return (x1, x2, x3, x4, x5, x6, x7);
}
@method_id(13)
fun test_tuple(x: int): tuple {
- var t: tuple = unsafe_tuple([x, x.`~inc`(x / 20), x, x = x * 2, x, x += 1, x]);
- return t;
+ var t: tuple = unsafe_tuple([x, x.`~inc`(x / 20), x, x = x * 2, x, x += 1, x]);
+ return t;
}
@method_id(14)
fun test_tuple_assign(x: int): (int, int, int, int, int, int, int) {
- var [x1: int, x2: int, x3: int, x4: int, x5: int, x6: int, x7: int] = [x, x.`~inc`(x / 20), x, x = x * 2, x, x += 1, x];
- return (x1, x2, x3, x4, x5, x6, x7);
+ var [x1: int, x2: int, x3: int, x4: int, x5: int, x6: int, x7: int] = [x, x.`~inc`(x / 20), x, x = x * 2, x, x += 1, x];
+ return (x1, x2, x3, x4, x5, x6, x7);
}
fun foo1(x1: int, x2: int, x3: int, x4: int, x5: int, x6: int, x7: int): (int, int, int, int, int, int, int) {
- return (x1, x2, x3, x4, x5, x6, x7);
+ return (x1, x2, x3, x4, x5, x6, x7);
}
@method_id(15)
fun test_call_1(x: int): (int, int, int, int, int, int, int) {
- return foo1(x, x.`~inc`(x / 20), x, x = x * 2, x, x += 1, x);
+ return foo1(x, x.`~inc`(x / 20), x, x = x * 2, x, x += 1, x);
}
fun foo2(x1: int, x2: int, x3456: (int, int, int, int), x7: int): (int, int, int, int, int, int, int) {
- var (x3: int, x4: int, x5: int, x6: int) = x3456;
- return (x1, x2, x3, x4, x5, x6, x7);
+ var (x3: int, x4: int, x5: int, x6: int) = x3456;
+ return (x1, x2, x3, x4, x5, x6, x7);
}
@method_id(16)
fun test_call_2(x: int): (int, int, int, int, int, int, int) {
- return foo2(x, x.`~inc`(x / 20), (x, x = x * 2, x, x += 1), x);
+ return foo2(x, x.`~inc`(x / 20), (x, x = x * 2, x, x += 1), x);
}
fun asm_func(x1: int, x2: int, x3: int, x4: int, x5: int, x6: int, x7: int): (int, int, int, int, int, int, int)
-asm
- (x4 x5 x6 x7 x1 x2 x3->0 1 2 3 4 5 6) "NOP";
+ asm (x4 x5 x6 x7 x1 x2 x3->0 1 2 3 4 5 6) "NOP";
@method_id(17)
fun test_call_asm_old(x: int): (int, int, int, int, int, int, int) {
- return asm_func(x, x += 1, x, x, x.`~inc`(x / 20), x, x = x * 2);
+ return asm_func(x, x += 1, x, x, x.`~inc`(x / 20), x, x = x * 2);
}
@method_id(18)
fun test_call_asm_new(x: int): (int, int, int, int, int, int, int) {
- return asm_func(x, x.`~inc`(x / 20), x, x = x * 2, x, x += 1, x);
+ return asm_func(x, x.`~inc`(x / 20), x, x = x * 2, x, x += 1, x);
}
global xx: int;
@method_id(19)
-fun test_global(x: int): (int, int, int, int, int, int, int) {
- xx = x;
- return (xx, xx.`~inc`(xx / 20), xx, xx = xx * 2, xx, xx += 1, xx);
+fun test_global(x: int) {
+ xx = x;
+ return (x, xx, xx.`~inc`(xx / 20), eq(xx += (x *= 0)), xx = xx * 2, xx, xx += 1, xx, x);
}
@method_id(20)
fun test_if_else(x: int): (int, int, int, int, int) {
- if (x > 10) {
- return (x.`~inc`(8), x + 1, x = 1, x <<= 3, x);
- } else {
- xx = 9;
- return (x, x.`~inc`(-4), x.`~inc`(-1), x >= 1, x = x + xx);
- }
+ if (x > 10) {
+ return (x.`~inc`(8), x + 1, x = 1, x <<= 3, x);
+ } else {
+ xx = 9;
+ return (x, x.`~inc`(-4), x.`~inc`(-1), (x >= 1) as int, x = x + xx);
+ }
+}
+
+@method_id(21)
+fun test_assign_with_inner(x: int) {
+ return (x, x += 10, [(x, x += 20, eq(x -= 50), x)], eq2((x, x *= eq(x /= 2))));
+}
+
+@method_id(22)
+fun test_assign_with_mutate(x: int) {
+ return (x, mul2(mutate x, x += 5), x.`~inc`(mul2(mutate x, x)), x);
+}
+
+@method_id(23)
+fun test_assign_tensor(x: (int, int)) {
+ var fs = (0, 0);
+ return (x, x = (20, 30), fs = x.multens((1, 2)), fs.multens(multens(mutate x, (-1, -1))), x, fs);
+}
+
+global fs: (int, int);
+@method_id(24)
+fun test_assign_tensor_global(x: (int, int)) {
+ fs = (0, 0);
+ return (x, x = (20, 30), fs = x.multens((1, 2)), fs.multens(multens(mutate x, (-1, -1))), x, fs);
}
fun main() {
@@ -96,9 +123,13 @@ fun main() {
@testcase | 16 | 100 | 100 50 105 210 210 211 211
@testcase | 17 | 100 | 101 50 106 212 100 101 101
@testcase | 18 | 100 | 210 210 211 211 100 50 105
-@testcase | 19 | 100 | 100 50 105 210 210 211 211
+@testcase | 19 | 100 | 100 100 50 105 210 210 211 211 0
@testcase | 20 | 80 | 80 89 1 8 8
@testcase | 20 | 9 | 9 -40 -10 -1 13
+@testcase | 21 | 100 | 100 110 [ 110 130 80 80 ] 80 3200
+@testcase | 22 | 100 | 100 210 4200 630
+@testcase | 23 | 1 1 | 1 1 20 30 20 60 -400 -3600 -20 -60 -400 -3600
+@testcase | 24 | 1 1 | 1 1 20 30 20 60 -400 -3600 -20 -60 -400 -3600
@fif_codegen
"""
@@ -107,5 +138,5 @@ fun main() {
inc CALLDICT // self newY
}>
"""
-@code_hash 97139400653362069936987769894397430077752335662822462908581556703209313861576
+@code_hash 7627024945492125068389905298530400936797031708759561372406088054030801992712
*/
diff --git a/tolk-tester/tests/assignment-tests.tolk b/tolk-tester/tests/assignment-tests.tolk
new file mode 100644
index 000000000..89de8cf44
--- /dev/null
+++ b/tolk-tester/tests/assignment-tests.tolk
@@ -0,0 +1,28 @@
+fun extractFromTypedTuple(params: [int]) {
+ var [payload: int] = params;
+ return payload + 10;
+}
+
+@method_id(101)
+fun test101(x: int) {
+ var params = [x];
+ return extractFromTypedTuple(params);
+}
+
+fun autoInferIntNull(x: int) {
+ if (x > 10) { return null; }
+ return x;
+}
+
+fun main(value: int) {
+ var (x: int, y) = (autoInferIntNull(value), autoInferIntNull(value * 2));
+ if (x == null && y == null) { return null; }
+ return x == null || y == null ? -1 : x + y;
+}
+
+/**
+@testcase | 0 | 3 | 9
+@testcase | 0 | 6 | -1
+@testcase | 0 | 11 | (null)
+@testcase | 101 | 78 | 88
+*/
diff --git a/tolk-tester/tests/bit-operators.tolk b/tolk-tester/tests/bit-operators.tolk
index 049406af9..4cb8e1ba1 100644
--- a/tolk-tester/tests/bit-operators.tolk
+++ b/tolk-tester/tests/bit-operators.tolk
@@ -1,20 +1,20 @@
-fun lshift(): int {
+fun lshift(): bool {
return (1 << 0) == 1;
}
-fun rshift(): int {
+fun rshift(): bool {
return (1 >> 0) == 1;
}
-fun lshift_var(i: int): int {
+fun lshift_var(i: int): bool {
return (1 << i) == 1;
}
-fun rshift_var(i: int): int {
+fun rshift_var(i: int): bool {
return (1 >> i) == 1;
}
-fun main(x: int): int {
+fun main(x: int): bool {
if (x == 0) {
return lshift();
} else if (x == 1) {
@@ -31,12 +31,71 @@ fun main(x: int): int {
}
@method_id(11)
-fun is_claimed(index: int): int {
+fun is_claimed(index: int): bool {
var claim_bit_index: int = index % 256;
var mask: int = 1 << claim_bit_index;
return (255 & mask) == mask;
}
+@method_id(12)
+fun bit_not(i: int, b: bool): (int, bool, bool, bool, int, bool) {
+ var i2 = ~i;
+ var b2 = !b;
+ var (i3: int, b3: bool) = (i2, b2);
+ return (i3, b3, !i, !b, ~~~i, !!!b);
+}
+
+@method_id(13)
+fun boolWithBitwiseConst() {
+ var found = true;
+ return (found & false, found | true, found ^ true, found & found);
+}
+
+global g14: int;
+fun getBool() { return (g14 += 1) > 2; }
+
+@method_id(14)
+fun boolWithBitwise(b: bool) {
+ g14 = 0;
+ return (b & getBool(), !b & getBool(), b | getBool(), !b | getBool(), b ^ getBool(), !b & getBool(), g14);
+}
+
+@method_id(15)
+fun boolWithBitwiseSet(b1: bool, b2: bool) {
+ b1 &= b2;
+ b2 |= true;
+ b1 |= b1 == false;
+ b2 ^= (b1 ^= b2);
+ return (b1, b2);
+}
+
+@method_id(16)
+fun testDoUntilCodegen(i: bool, n: int) {
+ var cnt = 0;
+ do { cnt += 1; } while (i);
+ do { cnt += 1; } while (!!i);
+ do { cnt += 1; } while (n);
+ return (cnt, !i, !n);
+}
+
+@method_id(17)
+fun testConstNegateCodegen() {
+ return (!0, !1, !true, !false, !!true, !!false);
+}
+
+@method_id(18)
+fun testBoolNegateOptimized(x: bool) {
+ return (x, !x, !!x, !!!x, !!!!true);
+}
+
+fun eqX(x: bool) { return x; }
+
+@method_id(19)
+fun testBoolCompareOptimized(x: bool) {
+ return (x == true, x != true, eqX(x) == false, eqX(x) != false, !!(x == !false));
+}
+
+
/**
method_id | in | out
@@ -50,4 +109,96 @@ fun is_claimed(index: int): int {
@testcase | 11 | 1 | -1
@testcase | 11 | 256 | -1
@testcase | 11 | 8 | 0
+@testcase | 12 | 0 0 | -1 -1 -1 -1 -1 -1
+@testcase | 12 | -1 -1 | 0 0 0 0 0 0
+@testcase | 12 | 7 0 | -8 -1 0 -1 -8 -1
+@testcase | 14 | -1 | 0 0 -1 -1 0 0 6
+@testcase | 14 | 0 | 0 0 -1 -1 -1 -1 6
+@testcase | 15 | -1 -1 | 0 -1
+@testcase | 15 | -1 0 | 0 -1
+@testcase | 16 | 0 0 | 3 -1 -1
+@testcase | 17 | | -1 0 0 -1 -1 0
+@testcase | 18 | 0 | 0 -1 0 -1 -1
+@testcase | 18 | -1 | -1 0 -1 0 -1
+@testcase | 19 | 0 | 0 -1 -1 0 0
+@testcase | 19 | -1 | -1 0 0 -1 -1
+
+@fif_codegen
+"""
+ boolWithBitwiseConst PROC:<{
+ //
+ 0 PUSHINT // _3
+ -1 PUSHINT // _3 _5
+ 0 PUSHINT // _3 _5 _7
+ -1 PUSHINT // _3 _5 _7 _8
+ }>
+"""
+
+@fif_codegen
+"""
+ testDoUntilCodegen PROC:<{
+ // i n
+ 0 PUSHINT // i n cnt=0
+ UNTIL:<{
+ INC // i n cnt
+ s2 PUSH // i n cnt i
+ NOT // i n cnt _6
+ }> // i n cnt
+ UNTIL:<{
+ INC // i n cnt
+ s2 PUSH // i n cnt i
+ NOT // i n cnt _9
+ }> // i n cnt
+ UNTIL:<{
+ INC // i n cnt
+ OVER // i n cnt n
+ 0 EQINT // i n cnt _12
+ }> // i n cnt
+ s0 s2 XCHG // cnt n i
+ NOT // cnt n _13
+ SWAP // cnt _13 n
+ 0 EQINT // cnt _13 _14
+ }>
+"""
+
+@fif_codegen
+"""
+ testConstNegateCodegen PROC:<{
+ //
+ TRUE // _0
+ FALSE // _0 _1
+ FALSE // _0 _1 _2
+ TRUE // _0 _1 _2 _3
+ TRUE // _0 _1 _2 _3 _4
+ FALSE // _0 _1 _2 _3 _4 _5
+ }>
+"""
+
+@fif_codegen
+"""
+ testBoolNegateOptimized PROC:<{
+ // x
+ DUP // x x
+ NOT // x _1
+ OVER // x _1 x
+ NOT // x _1 _2
+ s2 s(-1) PUXC
+ TRUE // x _1 x _2 _3
+ }>
+"""
+
+@fif_codegen
+"""
+ testBoolCompareOptimized PROC:<{
+ // x
+ DUP // x x
+ NOT // x _1
+ OVER // x _1 x
+ eqX CALLDICT // x _1 _2
+ NOT // x _1 _3
+ s2 PUSH // x _1 _3 x
+ eqX CALLDICT // x _1 _3 _4
+ s3 PUSH // x _1 _3 _4 x
+ }>
+"""
*/
diff --git a/tolk-tester/tests/c2.tolk b/tolk-tester/tests/c2.tolk
index ec8d32da4..257aba5b8 100644
--- a/tolk-tester/tests/c2.tolk
+++ b/tolk-tester/tests/c2.tolk
@@ -1,20 +1,21 @@
global op: (int, int) -> int;
-fun check_assoc(a: int, b: int, c: int): int {
+fun check_assoc(a: int, b: int, c: int): bool {
return op(op(a, b), c) == op(a, op(b, c));
}
-fun unnamed_args(_: int, _: slice, _: auto): auto {
+fun unnamed_args(_: int, _: slice, _: int) {
return true;
}
-fun main(x: int, y: int, z: int): int {
+fun main(x: int, y: int, z: int): bool {
op = `_+_`;
+ if (0) { return null; }
return check_assoc(x, y, z);
}
@method_id(101)
-fun test101(x: int, z: int): auto {
+fun test101(x: int, z: int) {
return unnamed_args(x, "asdf", z);
}
diff --git a/tolk-tester/tests/c2_1.tolk b/tolk-tester/tests/c2_1.tolk
index 4e52b9eeb..ef1e589ad 100644
--- a/tolk-tester/tests/c2_1.tolk
+++ b/tolk-tester/tests/c2_1.tolk
@@ -1,8 +1,8 @@
-fun check_assoc(op: auto, a: int, b: int, c: int) {
+fun check_assoc(op: (int, int) -> int, a: int, b: int, c: int) {
return op(op(a, b), c) == op(a, op(b, c));
}
-fun main(x: int, y: int, z: int): int {
+fun main(x: int, y: int, z: int): bool {
return check_assoc(`_+_`, x, y, z);
}
diff --git a/tolk-tester/tests/cells-slices.tolk b/tolk-tester/tests/cells-slices.tolk
index e1d28b8b1..6f316f2e6 100644
--- a/tolk-tester/tests/cells-slices.tolk
+++ b/tolk-tester/tests/cells-slices.tolk
@@ -162,8 +162,8 @@ fun test13() {
}
@method_id(114)
-fun test110(x: int) {
- var s = beginCell().storeBool(x < 0).storeBool(0).storeBool(x).endCell().beginParse();
+fun test110(x: bool) {
+ var s = beginCell().storeBool(x == true).storeBool(false).storeBool(x).endCell().beginParse();
return (s.loadBool(), s.loadBool(), s.loadBool());
}
@@ -179,15 +179,15 @@ fun test111() {
if (s.addressIsNone()) {
s.skipBits(2);
}
- if (s.loadBool() == 0) {
- assert(s.loadBool() == 0) throw 444;
+ if (s.loadBool() == false) {
+ assert(!s.loadBool()) throw 444;
s.skipBouncedPrefix();
}
var op2 = s.loadMessageOp();
var q2 = s.loadMessageQueryId();
s.skipBits(64);
s.assertEndOfSlice();
- assert(isMessageBounced(0x001)) throw 444;
+ assert(isMessageBounced(0x001) && !isMessageBounced(0x002)) throw 444;
return (op1, q1, op2, q2);
}
@@ -216,15 +216,15 @@ Note, that since 'compute-asm-ltr' became on be default, chaining methods codege
"""
test6 PROC:<{
//
- NEWC // _1
- 1 PUSHINT // _1 _2=1
- SWAP // _2=1 _1
+ NEWC // _0
+ 1 PUSHINT // _0 _1=1
+ SWAP // _1=1 _0
32 STU // _0
- 2 PUSHINT // _0 _6=2
- SWAP // _6=2 _0
+ 2 PUSHINT // _0 _5=2
+ SWAP // _5=2 _0
32 STU // _0
- 3 PUSHINT // _0 _10=3
- SWAP // _10=3 _0
+ 3 PUSHINT // _0 _9=3
+ SWAP // _9=3 _0
32 STU // _0
}>
"""
diff --git a/tolk-tester/tests/codegen_check_demo.tolk b/tolk-tester/tests/codegen_check_demo.tolk
index 02379540c..e40f03779 100644
--- a/tolk-tester/tests/codegen_check_demo.tolk
+++ b/tolk-tester/tests/codegen_check_demo.tolk
@@ -1,7 +1,7 @@
@method_id(101)
fun test1(): int {
- var x = false;
- if (x == true) {
+ var x: int = false as int;
+ if (x == true as int) {
x= 100500;
}
return x;
@@ -35,7 +35,7 @@ Below, I just give examples of @fif_codegen tag:
"""
main PROC:<{
// s
- 17 PUSHINT // s _3=17
+ 17 PUSHINT // s _1=17
OVER // s z=17 t
WHILE:<{
...
diff --git a/tolk-tester/tests/generics-1.tolk b/tolk-tester/tests/generics-1.tolk
new file mode 100644
index 000000000..0d872cc19
--- /dev/null
+++ b/tolk-tester/tests/generics-1.tolk
@@ -0,0 +1,150 @@
+fun eq1<X>(value: X): X { return value; }
+fun eq2<X>(value: X) { return value; }
+fun eq3<X>(value: X): X { var cp: [X] = [eq1(value)]; var ((([v: X]))) = cp; return v; }
+fun eq4<X>(value: X) { return eq1<X>(value); }
+
+@method_id(101)
+fun test101(x: int) {
+ var (a, b, c) = (x, (x,x), [x,x]);
+ return (eq1(a), eq1(b), eq1(c), eq2(a), eq2(b), eq2(c), eq3(a), eq4(b), eq3(createEmptyTuple()));
+}
+
+fun getTwo<X>(): X { return 2 as X; }
+
+fun takeInt(a: int) { return a; }
+
+@method_id(102)
+fun test102(): (int, int, int, [(int, int)]) {
+ var a: int = getTwo();
+ var _: int = getTwo();
+ var b = getTwo() as int;
+ var c: int = 1 ? getTwo() : getTwo();
+ var c redef = getTwo();
+ return (eq1<int>(a), eq2<int>(b), takeInt(getTwo()), [(getTwo(), getTwo())]);
+}
+
+@method_id(103)
+fun test103(first: int): (int, int, int) {
+ var t = createEmptyTuple();
+ var cs = beginCell().storeInt(100, 32).endCell().beginParse();
+ t.tuplePush(first);
+ t.tuplePush(2);
+ t.tuplePush(cs);
+ cs = t.tupleAt(2);
+ cs = t.tupleAt(2) as slice;
+ return (t.tupleAt(0), cs.loadInt(32), t.tupleAt<slice>(2).loadInt(32));
+}
+
+fun manyEq<T1, T2, T3>(a: T1, b: T2, c: T3): [T1, T2, T3] {
+ return [a, b, c];
+}
+
+@method_id(104)
+fun test104(f: int) {
+ return (
+ manyEq(1 ? 1 : 1, f ? 0 : null, !f ? getTwo() as int : null),
+ manyEq((f ? null as int : eq2(2), beginCell().storeBool(true).endCell().beginParse().loadBool()), 0, eq4(f))
+ );
+}
+
+fun calcSum<X>(x: X, y: X) { return x + y; }
+
+@method_id(105)
+fun test105() {
+ if (0) { calcSum(((0)), null); }
+ return (calcSum(1, 2));
+}
+
+fun calcYPlus1<Y>(value: Y) { return value + 1; }
+fun calcLoad32(cs: slice) { return cs.loadInt(32); }
+fun calcTensorPlus1(tens: (int, int)) { var (f, s) = tens; return (f + 1, s + 1); }
+fun calcTensorMul2(tens: (int, int)) { var (f, s) = tens; return (f * 2, s * 2); }
+fun cellToSlice(c: cell) { return c.beginParse(); }
+fun abstractTransform<X, Y, R>(xToY: (X) -> Y, yToR: (((Y))) -> R, initialX: X): R {
+ var y = xToY(initialX);
+ return yToR(y);
+}
+
+@method_id(106)
+fun test106() {
+ var c = beginCell().storeInt(106, 32).endCell();
+ return [
+ abstractTransform(cellToSlice, calcLoad32, c),
+ abstractTransform(calcYPlus1<int>, calcYPlus1<int>, 0),
+ abstractTransform(calcTensorPlus1, calcTensorMul2, (2, 2))
+ ];
+}
+
+fun callTupleFirst<X, Y>(t: X): Y { return t.tupleFirst(); }
+fun callTuplePush<T, V>(mutate self: T, v1: V, v2: V): self { self.tuplePush(v1); tuplePush(mutate self, v2); return self; }
+fun getTupleLastInt(t: tuple) { return t.tupleLast<int>(); }
+fun getTupleSize(t: tuple) { return t.tupleSize(); }
+fun callAnyFn<TObj, TResult>(f: (TObj) -> TResult, arg: TObj) { return f(arg); }
+fun callAnyFn2<TCallback>(f: TCallback, arg: tuple) { return f(arg); }
+
+global t107: tuple;
+
+@method_id(107)
+fun test107() {
+ t107 = createEmptyTuple();
+ callTuplePush(mutate t107, 1, 2);
+ t107.callTuplePush(3, 4).callTuplePush(5, 6);
+ var first: int = t107.callTupleFirst();
+ return (
+ callAnyFn<tuple, int>(getTupleSize, t107),
+ callAnyFn2(getTupleSize, t107),
+ first,
+ callTupleFirst(t107) as int,
+ callAnyFn(getTupleLastInt, t107),
+ callAnyFn2(getTupleLastInt, t107)
+ );
+}
+
+global g108: int;
+
+fun inc108(by: int) { g108 += by; }
+fun getInc108() { return inc108; }
+fun returnResult<RetT>(f: () -> RetT): RetT { return f(); }
+fun applyAndReturn<ArgT, RetT>(f: () -> (ArgT) -> RetT, arg: ArgT): () -> ArgT -> RetT {
+ f()(arg);
+ return f;
+}
+
+@method_id(108)
+fun test108() {
+ g108 = 0;
+ getInc108()(1);
+ returnResult<(int) -> void>(getInc108)(2);
+ applyAndReturn<int, void>(getInc108, 10)()(10);
+ returnResult(getInc108)(2);
+ applyAndReturn(getInc108, 10)()(10);
+ return g108;
+}
+
+fun main(x: int): (int, [[int, int]]) {
+ try { if(x) { throw (1, x); } }
+ catch (excNo, arg) { return (arg as int, [[eq2(arg as int), getTwo()]]); }
+ return (0, [[x, 1]]);
+}
+
+/**
+@testcase | 0 | 1 | 1 [ [ 1 2 ] ]
+@testcase | 101 | 0 | 0 0 0 [ 0 0 ] 0 0 0 [ 0 0 ] 0 0 0 []
+@testcase | 102 | | 2 2 2 [ 2 2 ]
+@testcase | 103 | 0 | 0 100 100
+@testcase | 104 | 0 | [ 1 (null) 2 ] [ 2 -1 0 0 ]
+@testcase | 105 | | 3
+@testcase | 106 | | [ 106 2 6 6 ]
+@testcase | 107 | | 6 6 1 1 6 6
+@testcase | 108 | | 45
+
+@fif_codegen DECLPROC eq1<int>
+@fif_codegen DECLPROC eq1<tuple>
+@fif_codegen DECLPROC eq1<(int,int)>
+@fif_codegen DECLPROC eq1<[int,int]>
+@fif_codegen DECLPROC getTwo<int>
+
+@fif_codegen_avoid DECLPROC eq1
+@fif_codegen_avoid DECLPROC eq2
+@fif_codegen_avoid DECLPROC eq3
+ */
diff --git a/tolk-tester/tests/imports/use-dicts.tolk b/tolk-tester/tests/imports/use-dicts.tolk
index 26a9a9ccd..c9d5dcfea 100644
--- a/tolk-tester/tests/imports/use-dicts.tolk
+++ b/tolk-tester/tests/imports/use-dicts.tolk
@@ -11,7 +11,7 @@ fun prepareDict_3_30_4_40_5_x(valueAt5: int): cell {
fun lookupIdxByValue(idict32: cell, value: int): int {
var cur_key = -1;
do {
- var (cur_key redef, cs: slice, found: int) = idict32.iDictGetNext(32, cur_key);
+ var (cur_key redef, cs: slice, found: bool) = idict32.iDictGetNext(32, cur_key);
// one-line condition (via &) doesn't work, since right side is calculated immediately
if (found) {
if (cs.loadInt(32) == value) {
diff --git a/tolk-tester/tests/invalid-call-1.tolk b/tolk-tester/tests/invalid-call-1.tolk
index 1c32422ee..3542f5809 100644
--- a/tolk-tester/tests/invalid-call-1.tolk
+++ b/tolk-tester/tests/invalid-call-1.tolk
@@ -1,9 +1,10 @@
-fun main() {
- return true();
+const asdf = 1;
+
+fun main(x: int) {
+ return x.asdf();
}
/**
@compilation_should_fail
-The message is weird now, but later I'll rework error messages anyway.
-@stderr cannot apply expression of type int to an expression of type (): cannot unify type () -> ??3 with int
+@stderr calling a non-function
*/
diff --git a/tolk-tester/tests/invalid-call-5.tolk b/tolk-tester/tests/invalid-call-5.tolk
index 89ab026a9..32905cd77 100644
--- a/tolk-tester/tests/invalid-call-5.tolk
+++ b/tolk-tester/tests/invalid-call-5.tolk
@@ -8,6 +8,6 @@ fun main() {
/**
@compilation_should_fail
-@stderr rvalue expected
+@stderr `_` can't be used as a value; it's a placeholder for a left side of assignment
@stderr inc(_)
*/
diff --git a/tolk-tester/tests/invalid-call-9.tolk b/tolk-tester/tests/invalid-call-9.tolk
new file mode 100644
index 000000000..87eb61e84
--- /dev/null
+++ b/tolk-tester/tests/invalid-call-9.tolk
@@ -0,0 +1,10 @@
+fun getOne() { return 1; }
+
+fun main() {
+ return getOne<int>();
+}
+
+/**
+@compilation_should_fail
+@stderr calling a not generic function with generic T
+ */
diff --git a/tolk-tester/tests/invalid-const-1.tolk b/tolk-tester/tests/invalid-const-1.tolk
new file mode 100644
index 000000000..10e8303ad
--- /dev/null
+++ b/tolk-tester/tests/invalid-const-1.tolk
@@ -0,0 +1,8 @@
+fun main() {
+ return 9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999;
+}
+
+/**
+@compilation_should_fail
+@stderr invalid integer constant
+ */
diff --git a/tolk-tester/tests/invalid-declaration-11.tolk b/tolk-tester/tests/invalid-declaration-11.tolk
new file mode 100644
index 000000000..75ebb450b
--- /dev/null
+++ b/tolk-tester/tests/invalid-declaration-11.tolk
@@ -0,0 +1,13 @@
+// this function is declared incorrectly,
+// since it should return 2 values onto a stack (1 for returned slice, 1 for mutated int)
+// but contains not 2 numbers in asm ret_order
+fun loadAddress2(mutate self: int): slice
+ asm( -> 1 0 2) "LDMSGADDR";
+
+fun main(){}
+
+/**
+@compilation_should_fail
+@stderr ret_order (after ->) expected to contain 2 numbers
+@stderr asm( -> 1 0 2)
+ */
diff --git a/tolk-tester/tests/invalid-declaration-12.tolk b/tolk-tester/tests/invalid-declaration-12.tolk
new file mode 100644
index 000000000..25ae9de60
--- /dev/null
+++ b/tolk-tester/tests/invalid-declaration-12.tolk
@@ -0,0 +1,16 @@
+fun proxy(x: int) {
+ return factorial(x);
+}
+
+fun factorial(x: int) {
+ if (x <= 0) {
+ return 1;
+ }
+ return x * proxy(x-1);
+}
+
+/**
+@compilation_should_fail
+@stderr could not infer return type of `factorial`, because it appears in a recursive call chain
+@stderr fun factorial
+ */
diff --git a/tolk-tester/tests/invalid-declaration-13.tolk b/tolk-tester/tests/invalid-declaration-13.tolk
new file mode 100644
index 000000000..758a4f21d
--- /dev/null
+++ b/tolk-tester/tests/invalid-declaration-13.tolk
@@ -0,0 +1,7 @@
+const c: slice = 123 + 456;
+
+/**
+@compilation_should_fail
+@stderr expression type does not match declared type
+@stderr const c
+ */
diff --git a/tolk-tester/tests/invalid-generics-1.tolk b/tolk-tester/tests/invalid-generics-1.tolk
new file mode 100644
index 000000000..c8ff7fec3
--- /dev/null
+++ b/tolk-tester/tests/invalid-generics-1.tolk
@@ -0,0 +1,10 @@
+fun f<X>(v: int, x: X) {}
+
+fun failCantDeduceWithoutArgument() {
+ return f(1);
+}
+
+/**
+@compilation_should_fail
+@stderr can not deduce X for generic function `f<X>`
+ */
diff --git a/tolk-tester/tests/invalid-generics-10.tolk b/tolk-tester/tests/invalid-generics-10.tolk
new file mode 100644
index 000000000..c7f72bf4d
--- /dev/null
+++ b/tolk-tester/tests/invalid-generics-10.tolk
@@ -0,0 +1,9 @@
+fun invalidReferencingGenericMethodWithoutGeneric() {
+ var t = createEmptyTuple();
+ var cb = t.tupleLast;
+}
+
+/**
+@compilation_should_fail
+@stderr can not use a generic function `tupleLast<T>` as non-call
+ */
diff --git a/tolk-tester/tests/invalid-generics-11.tolk b/tolk-tester/tests/invalid-generics-11.tolk
new file mode 100644
index 000000000..a399bc917
--- /dev/null
+++ b/tolk-tester/tests/invalid-generics-11.tolk
@@ -0,0 +1,11 @@
+global gVar: int;
+
+fun main() {
+ var x = gVar<int>;
+ return x;
+}
+
+/**
+@compilation_should_fail
+@stderr generic T not expected here
+ */
diff --git a/tolk-tester/tests/invalid-generics-2.tolk b/tolk-tester/tests/invalid-generics-2.tolk
new file mode 100644
index 000000000..155944338
--- /dev/null
+++ b/tolk-tester/tests/invalid-generics-2.tolk
@@ -0,0 +1,10 @@
+fun f<T>(v: int, x: T) {}
+
+fun failCantDeduceWithPlainNull() {
+ return f(0, null);
+}
+
+/**
+@compilation_should_fail
+@stderr can not deduce T for generic function `f<T>`
+ */
diff --git a/tolk-tester/tests/invalid-generics-3.tolk b/tolk-tester/tests/invalid-generics-3.tolk
new file mode 100644
index 000000000..72b7df0ec
--- /dev/null
+++ b/tolk-tester/tests/invalid-generics-3.tolk
@@ -0,0 +1,11 @@
+fun f<T>(x: T, y: T) {}
+
+fun failIncompatibleTypesForT() {
+ return f(32, "");
+}
+
+/**
+@compilation_should_fail
+@stderr T is both int and slice for generic function `f<T>`
+@stderr f(32
+ */
diff --git a/tolk-tester/tests/invalid-generics-4.tolk b/tolk-tester/tests/invalid-generics-4.tolk
new file mode 100644
index 000000000..07472ba37
--- /dev/null
+++ b/tolk-tester/tests/invalid-generics-4.tolk
@@ -0,0 +1,10 @@
+fun f<T>(x: T): void asm "NOP";
+
+fun failInstantiatingAsmFunctionWithNon1Slot() {
+ f((1, 2));
+}
+
+/**
+@compilation_should_fail
+@stderr can not call `f<T>` with T=(int, int), because it occupies 2 stack slots in TVM, not 1
+ */
diff --git a/tolk-tester/tests/invalid-generics-5.tolk b/tolk-tester/tests/invalid-generics-5.tolk
new file mode 100644
index 000000000..4d4f29674
--- /dev/null
+++ b/tolk-tester/tests/invalid-generics-5.tolk
@@ -0,0 +1,10 @@
+fun f<T>(x: T): void asm "NOP";
+
+fun failUsingGenericFunctionPartially() {
+ var cb = f;
+}
+
+/**
+@compilation_should_fail
+@stderr can not use a generic function `f<T>` as non-call
+ */
diff --git a/tolk-tester/tests/invalid-generics-6.tolk b/tolk-tester/tests/invalid-generics-6.tolk
new file mode 100644
index 000000000..73e6403fd
--- /dev/null
+++ b/tolk-tester/tests/invalid-generics-6.tolk
@@ -0,0 +1,10 @@
+fun eq<X>(t: X) { return t; }
+
+fun failUsingGenericFunctionPartially() {
+ var cb = createEmptyTuple().eq().eq().tuplePush;
+}
+
+/**
+@compilation_should_fail
+@stderr can not use a generic function `tuplePush<T>` as non-call
+ */
diff --git a/tolk-tester/tests/invalid-generics-7.tolk b/tolk-tester/tests/invalid-generics-7.tolk
new file mode 100644
index 000000000..b51bb82cd
--- /dev/null
+++ b/tolk-tester/tests/invalid-generics-7.tolk
@@ -0,0 +1,18 @@
+fun failOnInstantiation(a: slice) {
+ var b: slice = foo(a);
+}
+
+fun bar<X>(value: X) : X {
+ return 1;
+}
+fun foo<X>(value: X) : X {
+ return bar(value);
+}
+
+/**
+@compilation_should_fail
+@stderr while instantiating generic function `foo<slice>`
+@stderr while instantiating generic function `bar<slice>`
+@stderr can not convert type `int` to return type `slice`
+@stderr return 1
+ */
diff --git a/tolk-tester/tests/invalid-generics-8.tolk b/tolk-tester/tests/invalid-generics-8.tolk
new file mode 100644
index 000000000..d2c24e532
--- /dev/null
+++ b/tolk-tester/tests/invalid-generics-8.tolk
@@ -0,0 +1,11 @@
+fun withT1T2<T1, T2>(a: (T1, T2)) {}
+
+fun wrongTCountPassed() {
+ withT1T2<int>((5, ""));
+}
+
+/**
+@compilation_should_fail
+@stderr wrong count of generic T: expected 2, got 1
+@stderr <int>
+ */
diff --git a/tolk-tester/tests/invalid-generics-9.tolk b/tolk-tester/tests/invalid-generics-9.tolk
new file mode 100644
index 000000000..73fd6f87c
--- /dev/null
+++ b/tolk-tester/tests/invalid-generics-9.tolk
@@ -0,0 +1,8 @@
+fun invalidProvidingGenericTsToNotGeneric() {
+ beginCell<builder>();
+}
+
+/**
+@compilation_should_fail
+@stderr calling a not generic function with generic T
+ */
diff --git a/tolk-tester/tests/invalid-mutate-1.tolk b/tolk-tester/tests/invalid-mutate-1.tolk
index 237940fc9..280d1e998 100644
--- a/tolk-tester/tests/invalid-mutate-1.tolk
+++ b/tolk-tester/tests/invalid-mutate-1.tolk
@@ -7,5 +7,5 @@ fun cantAssignToVal() {
/**
@compilation_should_fail
-@stderr modifying an immutable variable `x`
+@stderr modifying immutable variable `x`
*/
diff --git a/tolk-tester/tests/invalid-mutate-11.tolk b/tolk-tester/tests/invalid-mutate-11.tolk
index 9f2c2601e..dfc69851c 100644
--- a/tolk-tester/tests/invalid-mutate-11.tolk
+++ b/tolk-tester/tests/invalid-mutate-11.tolk
@@ -4,5 +4,5 @@ fun load32(self: slice): int {
/**
@compilation_should_fail
-@stderr modifying `self` (call a mutating method), which is immutable by default
+@stderr modifying `self`, which is immutable by default
*/
diff --git a/tolk-tester/tests/invalid-mutate-16.tolk b/tolk-tester/tests/invalid-mutate-16.tolk
new file mode 100644
index 000000000..9da6e2534
--- /dev/null
+++ b/tolk-tester/tests/invalid-mutate-16.tolk
@@ -0,0 +1,9 @@
+fun cantCallMutatingFunctionWithAssignmentLValue() {
+ var t: tuple = createEmptyTuple();
+ (t = createEmptyTuple()).tuplePush(1);
+}
+
+/**
+@compilation_should_fail
+@stderr assignment can not be used as lvalue
+ */
diff --git a/tolk-tester/tests/invalid-mutate-17.tolk b/tolk-tester/tests/invalid-mutate-17.tolk
new file mode 100644
index 000000000..9327f07d8
--- /dev/null
+++ b/tolk-tester/tests/invalid-mutate-17.tolk
@@ -0,0 +1,13 @@
+@pure
+fun tupleMut(mutate self: tuple): int
+ asm "TLEN";
+
+fun main() {
+ var t = createEmptyTuple();
+ return [[t.tupleMut]];
+}
+
+/**
+@compilation_should_fail
+@stderr saving `tupleMut` into a variable is impossible, since it has `mutate` parameters
+ */
diff --git a/tolk-tester/tests/invalid-mutate-2.tolk b/tolk-tester/tests/invalid-mutate-2.tolk
index 7501fdaf5..71afe7300 100644
--- a/tolk-tester/tests/invalid-mutate-2.tolk
+++ b/tolk-tester/tests/invalid-mutate-2.tolk
@@ -6,5 +6,5 @@ fun cantAssignToVal() {
/**
@compilation_should_fail
-@stderr modifying an immutable variable `x`
+@stderr modifying immutable variable `x`
*/
diff --git a/tolk-tester/tests/invalid-mutate-3.tolk b/tolk-tester/tests/invalid-mutate-3.tolk
index c49973f71..d556c9ed9 100644
--- a/tolk-tester/tests/invalid-mutate-3.tolk
+++ b/tolk-tester/tests/invalid-mutate-3.tolk
@@ -7,5 +7,5 @@ fun cantAssignToConst() {
/**
@compilation_should_fail
-@stderr modifying an immutable variable `op_increase`
+@stderr modifying immutable constant
*/
diff --git a/tolk-tester/tests/invalid-mutate-4.tolk b/tolk-tester/tests/invalid-mutate-4.tolk
index f25a707cb..5f2c111d5 100644
--- a/tolk-tester/tests/invalid-mutate-4.tolk
+++ b/tolk-tester/tests/invalid-mutate-4.tolk
@@ -10,5 +10,5 @@ fun cantPassToMutatingFunction() {
/**
@compilation_should_fail
-@stderr modifying an immutable variable `myVal`
+@stderr modifying immutable variable `myVal`
*/
diff --git a/tolk-tester/tests/invalid-mutate-5.tolk b/tolk-tester/tests/invalid-mutate-5.tolk
index fd8d11924..2b282cf0d 100644
--- a/tolk-tester/tests/invalid-mutate-5.tolk
+++ b/tolk-tester/tests/invalid-mutate-5.tolk
@@ -9,6 +9,6 @@ fun cantCallMutatingMethod(c: cell) {
/**
@compilation_should_fail
-@stderr modifying an immutable variable `s` (call a mutating method)
+@stderr modifying immutable variable `s`
@stderr s.loadUint
*/
diff --git a/tolk-tester/tests/invalid-mutate-6.tolk b/tolk-tester/tests/invalid-mutate-6.tolk
index bb577ae47..749d9cab2 100644
--- a/tolk-tester/tests/invalid-mutate-6.tolk
+++ b/tolk-tester/tests/invalid-mutate-6.tolk
@@ -11,6 +11,6 @@ fun cantCallMutatingFunctionWithImmutable() {
/**
@compilation_should_fail
-@stderr modifying an immutable variable `op_increase` (call a mutating function)
+@stderr modifying immutable constant
@stderr inc(mutate op_increase)
*/
diff --git a/tolk-tester/tests/invalid-mutate-7.tolk b/tolk-tester/tests/invalid-mutate-7.tolk
index 5b6b6afe4..de3bce454 100644
--- a/tolk-tester/tests/invalid-mutate-7.tolk
+++ b/tolk-tester/tests/invalid-mutate-7.tolk
@@ -10,6 +10,6 @@ fun cantCallMutatingFunctionWithRvalue() {
/**
@compilation_should_fail
-@stderr lvalue expected (call a mutating function)
+@stderr literal can not be used as lvalue
@stderr incBoth(mutate x, mutate 30)
*/
diff --git a/tolk-tester/tests/invalid-mutate-8.tolk b/tolk-tester/tests/invalid-mutate-8.tolk
index 0dd7c5687..9b14e28f7 100644
--- a/tolk-tester/tests/invalid-mutate-8.tolk
+++ b/tolk-tester/tests/invalid-mutate-8.tolk
@@ -6,5 +6,5 @@ fun cantRedefImmutable() {
/**
@compilation_should_fail
-@stderr modifying an immutable variable `x` (left side of assignment)
+@stderr `redef` for immutable variable
*/
diff --git a/tolk-tester/tests/invalid-mutate-9.tolk b/tolk-tester/tests/invalid-mutate-9.tolk
index 7e79052e4..3489a2889 100644
--- a/tolk-tester/tests/invalid-mutate-9.tolk
+++ b/tolk-tester/tests/invalid-mutate-9.tolk
@@ -4,6 +4,6 @@ fun increment(self: int) {
/**
@compilation_should_fail
-@stderr modifying `self` (left side of assignment), which is immutable by default
+@stderr modifying `self`, which is immutable by default
@stderr probably, you want to declare `mutate self`
*/
diff --git a/tolk-tester/tests/invalid-nopar-4.tolk b/tolk-tester/tests/invalid-nopar-4.tolk
index 6e833f995..033c483ec 100644
--- a/tolk-tester/tests/invalid-nopar-4.tolk
+++ b/tolk-tester/tests/invalid-nopar-4.tolk
@@ -4,5 +4,5 @@ fun load_u32(cs: slice): (slice, int) {
/**
@compilation_should_fail
-@stderr expected `(`, got `32`
+@stderr expected `;`, got `32`
*/
diff --git a/tolk-tester/tests/invalid-pure-1.tolk b/tolk-tester/tests/invalid-pure-1.tolk
index 5baa32922..4f0e9142a 100644
--- a/tolk-tester/tests/invalid-pure-1.tolk
+++ b/tolk-tester/tests/invalid-pure-1.tolk
@@ -4,7 +4,7 @@ fun f_pure(): int {
return f_impure();
}
-fun f_impure(): int {}
+fun f_impure(): int { return 0; }
fun main(): int {
return f_pure();
diff --git a/tolk-tester/tests/invalid-pure-3.tolk b/tolk-tester/tests/invalid-pure-3.tolk
index f64b81ce7..31d4f0213 100644
--- a/tolk-tester/tests/invalid-pure-3.tolk
+++ b/tolk-tester/tests/invalid-pure-3.tolk
@@ -2,6 +2,7 @@
fun validate_input(input: cell): (int, int) {
var (x, y, z, correct) = calculateCellSize(input, 10);
assert(correct) throw 102;
+ return (x, y);
}
@pure
diff --git a/tolk-tester/tests/invalid-redefinition-6.tolk b/tolk-tester/tests/invalid-redefinition-6.tolk
new file mode 100644
index 000000000..e6b087c64
--- /dev/null
+++ b/tolk-tester/tests/invalid-redefinition-6.tolk
@@ -0,0 +1,10 @@
+const s1 = "asdf";
+
+fun main() {
+ var s1 redef = "d";
+}
+
+/**
+@compilation_should_fail
+@stderr `redef` for unknown variable
+ */
diff --git a/tolk-tester/tests/invalid-self-4.tolk b/tolk-tester/tests/invalid-self-4.tolk
index f4856a465..0be6b9e4d 100644
--- a/tolk-tester/tests/invalid-self-4.tolk
+++ b/tolk-tester/tests/invalid-self-4.tolk
@@ -4,6 +4,6 @@ fun cantReturnNothingFromSelf(mutate self: int): self {
/**
@compilation_should_fail
-@stderr missing return; forgot `return self`?
+@stderr missing return
@stderr }
*/
diff --git a/tolk-tester/tests/invalid-syntax-3.tolk b/tolk-tester/tests/invalid-syntax-3.tolk
index 26ce82ac5..259ea7958 100644
--- a/tolk-tester/tests/invalid-syntax-3.tolk
+++ b/tolk-tester/tests/invalid-syntax-3.tolk
@@ -4,5 +4,5 @@ fun main(x: int) {
/**
@compilation_should_fail
-@stderr null is not a function: use `null`, not `null()`
+@stderr calling a non-function
*/
diff --git a/tolk-tester/tests/invalid.tolk b/tolk-tester/tests/invalid-syntax-5.tolk
similarity index 100%
rename from tolk-tester/tests/invalid.tolk
rename to tolk-tester/tests/invalid-syntax-5.tolk
diff --git a/tolk-tester/tests/invalid-syntax-6.tolk b/tolk-tester/tests/invalid-syntax-6.tolk
new file mode 100644
index 000000000..12e026459
--- /dev/null
+++ b/tolk-tester/tests/invalid-syntax-6.tolk
@@ -0,0 +1,9 @@
+fun main() {
+ var a = 1;
+ (a += 1) += 2;
+}
+
+/**
+@compilation_should_fail
+@stderr assignment can not be used as lvalue
+*/
diff --git a/tolk-tester/tests/invalid-syntax-7.tolk b/tolk-tester/tests/invalid-syntax-7.tolk
new file mode 100644
index 000000000..9f63ac104
--- /dev/null
+++ b/tolk-tester/tests/invalid-syntax-7.tolk
@@ -0,0 +1,9 @@
+fun main() {
+ var x = 1;
+ x += (var y = 2);
+}
+
+/**
+@compilation_should_fail
+@stderr expected <expression>, got `var`
+*/
diff --git a/tolk-tester/tests/invalid-typing-1.tolk b/tolk-tester/tests/invalid-typing-1.tolk
index a0fe296d8..0089bd62f 100644
--- a/tolk-tester/tests/invalid-typing-1.tolk
+++ b/tolk-tester/tests/invalid-typing-1.tolk
@@ -6,5 +6,5 @@ fun main() {
/**
@compilation_should_fail
@stderr .tolk:2
-@stderr expected <type>, got `scli`
+@stderr unknown type name `scli`
*/
diff --git a/tolk-tester/tests/invalid-typing-10.tolk b/tolk-tester/tests/invalid-typing-10.tolk
new file mode 100644
index 000000000..8c1df4a26
--- /dev/null
+++ b/tolk-tester/tests/invalid-typing-10.tolk
@@ -0,0 +1,8 @@
+fun failMathOnBoolean(c: cell) {
+ return (null == c) * 10;
+}
+
+/**
+@compilation_should_fail
+@stderr can not apply operator `*` to `bool` and `int`
+ */
diff --git a/tolk-tester/tests/invalid-typing-11.tolk b/tolk-tester/tests/invalid-typing-11.tolk
new file mode 100644
index 000000000..d6aa09c30
--- /dev/null
+++ b/tolk-tester/tests/invalid-typing-11.tolk
@@ -0,0 +1,11 @@
+fun failBitwiseNotOnBool() {
+ var eq = 1 == 0;
+ if (~eq) {
+ return 0;
+ }
+}
+
+/**
+@compilation_should_fail
+@stderr can not apply operator `~` to `bool`
+ */
diff --git a/tolk-tester/tests/invalid-typing-12.tolk b/tolk-tester/tests/invalid-typing-12.tolk
new file mode 100644
index 000000000..3a5b1fe28
--- /dev/null
+++ b/tolk-tester/tests/invalid-typing-12.tolk
@@ -0,0 +1,10 @@
+fun failAssignNullToTensor() {
+ var ab = (1, 2);
+ ab = null;
+ return ab;
+}
+
+/**
+@compilation_should_fail
+@stderr can not assign `null` to variable of type `(int, int)`
+ */
diff --git a/tolk-tester/tests/invalid-typing-2.tolk b/tolk-tester/tests/invalid-typing-2.tolk
index d7c6745f5..052596e4c 100644
--- a/tolk-tester/tests/invalid-typing-2.tolk
+++ b/tolk-tester/tests/invalid-typing-2.tolk
@@ -1,9 +1,9 @@
fun main() {
- var tri: (int, bool) = (10, false);
+ var tri: (int, int) = (10, false);
return;
}
/**
@compilation_should_fail
-@stderr bool type is not supported yet
+@stderr can not assign `(int, bool)` to variable of type `(int, int)`
*/
diff --git a/tolk-tester/tests/invalid-typing-3.tolk b/tolk-tester/tests/invalid-typing-3.tolk
index fb4b0bc51..ac019a421 100644
--- a/tolk-tester/tests/invalid-typing-3.tolk
+++ b/tolk-tester/tests/invalid-typing-3.tolk
@@ -15,5 +15,5 @@ fun cantMixDifferentThis() {
/**
@compilation_should_fail
-@stderr cannot apply function appendBuilder : builder -> (builder, ()) to arguments of type int: cannot unify type int with builder
+@stderr can not call method for `builder` with object of type `int`
*/
diff --git a/tolk-tester/tests/invalid-typing-4.tolk b/tolk-tester/tests/invalid-typing-4.tolk
index 0e6553690..1ee71290c 100644
--- a/tolk-tester/tests/invalid-typing-4.tolk
+++ b/tolk-tester/tests/invalid-typing-4.tolk
@@ -7,8 +7,6 @@ fun cantCallNotChainedMethodsInAChain(x: int) {
}
/**
-The error is very weird, but nevertheless, the type system prevents of doing such errors.
-
@compilation_should_fail
-@stderr cannot apply function incNotChained : int -> (int, ()) to arguments of type (): cannot unify type () with int
+@stderr can not call method for `int` with object of type `void`
*/
diff --git a/tolk-tester/tests/invalid-typing-5.tolk b/tolk-tester/tests/invalid-typing-5.tolk
index ba3450de2..9d8cd480d 100644
--- a/tolk-tester/tests/invalid-typing-5.tolk
+++ b/tolk-tester/tests/invalid-typing-5.tolk
@@ -7,8 +7,7 @@ fun failWhenReturnANotChainedValue(x: int): int {
}
/**
-The error is very weird, but nevertheless, the type system prevents of doing such errors.
-
@compilation_should_fail
-@stderr previous function return type int cannot be unified with return statement expression type (): cannot unify type () with int
+@stderr x.incNotChained()
+@stderr can not convert type `void` to return type `int`
*/
diff --git a/tolk-tester/tests/invalid-typing-6.tolk b/tolk-tester/tests/invalid-typing-6.tolk
new file mode 100644
index 000000000..f2e99c7dd
--- /dev/null
+++ b/tolk-tester/tests/invalid-typing-6.tolk
@@ -0,0 +1,8 @@
+fun failWhenTernaryConditionNotInt(cs: slice) {
+ return cs ? 1 : 0;
+}
+
+/**
+@compilation_should_fail
+@stderr can not use `slice` as a boolean condition
+ */
diff --git a/tolk-tester/tests/invalid-typing-7.tolk b/tolk-tester/tests/invalid-typing-7.tolk
new file mode 100644
index 000000000..c192a05b8
--- /dev/null
+++ b/tolk-tester/tests/invalid-typing-7.tolk
@@ -0,0 +1,9 @@
+fun failAssignPlainNullToVariable() {
+ var x = null;
+}
+
+/**
+@compilation_should_fail
+@stderr can not infer type of `x`, it's always null
+@stderr specify its type with `x: <type>` or use `null as <type>`
+ */
diff --git a/tolk-tester/tests/invalid-typing-8.tolk b/tolk-tester/tests/invalid-typing-8.tolk
new file mode 100644
index 000000000..d696e1320
--- /dev/null
+++ b/tolk-tester/tests/invalid-typing-8.tolk
@@ -0,0 +1,8 @@
+fun failExplicitCastIncompatible(c: cell) {
+ return c as slice;
+}
+
+/**
+@compilation_should_fail
+@stderr type `cell` can not be cast to `slice`
+ */
diff --git a/tolk-tester/tests/invalid-typing-9.tolk b/tolk-tester/tests/invalid-typing-9.tolk
new file mode 100644
index 000000000..a0d5ee04e
--- /dev/null
+++ b/tolk-tester/tests/invalid-typing-9.tolk
@@ -0,0 +1,13 @@
+fun getTupleLastGetter<X>(): tuple -> X {
+ return tupleLast<X>;
+}
+
+fun failTypeMismatch() {
+ var t = createEmptyTuple();
+ var c: cell = getTupleLastGetter<int>()(t);
+}
+
+/**
+@compilation_should_fail
+@stderr can not assign `int` to variable of type `cell`
+ */
diff --git a/tolk-tester/tests/logical-operators.tolk b/tolk-tester/tests/logical-operators.tolk
index e9774f3f4..fb437bb34 100644
--- a/tolk-tester/tests/logical-operators.tolk
+++ b/tolk-tester/tests/logical-operators.tolk
@@ -1,14 +1,14 @@
import "imports/use-dicts.tolk"
fun simpleAllConst() {
- return (!0, !!0 & !false, !!!0, !1, !!1, !-1, !!-1, (!5 == 0) == !0, !0 == true);
+ return (!0, !!0 & !false, !!!0, !1, !!1, !-1, !!-1, (!5 as int == 0) == !0, !0 == true);
}
fun compileTimeEval1(x: int) {
// todo now compiler doesn't understand that bool can't be equal to number other than 0/-1
// (but understands that it can't be positive)
// that's why for now, the last condition is evaluated at runtime
- return (!x, !x > 10, !x < 10, !!x == 5, !x == -10);
+ return (!x, !x as int > 10, (!x as int) < 10, !!x as int == 5, !x as int == -10);
}
@method_id(101)
@@ -23,13 +23,13 @@ fun withAndOr(x: int, y: int, z: int) {
var return_at_end = -1;
if (!x & !y) {
if (!z & !y) { return 10; }
- else if (z | !!y) { return_at_end = 20; }
+ else if ((z != 0) | !!y) { return_at_end = 20; }
} else if (!!x & !!y & !z) {
if (!z & (x > 10)) { return_at_end = 30; }
if ((x != 11) & !z) { return 40; }
return_at_end = 50;
} else {
- return_at_end = !x ? !y : !z | 1;
+ return_at_end = !x ? !y as int : (!z as int) | 1;
}
return return_at_end;
}
@@ -54,7 +54,8 @@ fun testDict(last: int) {
@method_id(105)
fun testNotNull(x: int) {
- return [x == null, null == x, !(x == null), null == null, +(null != null)];
+ // return [x == null, null == x, !(x == null), null == null, +(null != null)];
+ return [x == null, null == x, !(x == null)];
}
@method_id(106)
@@ -123,6 +124,31 @@ fun testLogicalOps2(first: int) {
return (s.getRemainingBitsCount(), sum);
}
+@method_id(112)
+fun mixLogicalIntsAndBools(first: int, cond: bool) {
+ return (
+ (first && cond) || (!first && cond),
+ ((first & -1) & cond as int) == ((first && true) && cond) as int,
+ 7 && cond,
+ first || cond || !cond || alwaysThrows(),
+ cond || first || !first || alwaysThrows()
+ );
+}
+
+@method_id(113)
+fun testConvertIfToIfnot(x: bool) {
+ assert(!!(x == false), 100);
+ assert(!x, 100);
+ if (x == !!false) {
+ return 1;
+ }
+ if (!!(x != !false)) {
+ return 1;
+ }
+ assert(!!x, 100);
+ return -4;
+}
+
fun main() {
}
@@ -144,8 +170,8 @@ fun main() {
@testcase | 104 | 50 | 3 5 -1
@testcase | 104 | 100 | 3 5 5
@testcase | 104 | 0 | 3 -1 5
-@testcase | 105 | 0 | [ 0 0 -1 -1 0 ]
-@testcase | 105 | null | [ -1 -1 0 -1 0 ]
+@testcase | 105 | 0 | [ 0 0 -1 ]
+@testcase | 105 | null | [ -1 -1 0 ]
@testcase | 106 | | [ 0 0 0 -1 ] [ 0 0 0 ] [ -1 -1 -1 ] [ 0 -1 ]
@testcase | 107 | | [ -1 -1 0 -1 ] [ 0 0 0 ] [ -1 -1 -1 ] [ -1 0 ]
@testcase | 108 | 1 2 | -1
@@ -159,18 +185,21 @@ fun main() {
@testcase | 110 | 500 | -1 -1 0 -1 -1 3
@testcase | 111 | 0 | 32 4
@testcase | 111 | -1 | 0 8
+@testcase | 112 | 5 0 | 0 -1 0 -1 -1
+@testcase | 112 | 0 -1 | -1 -1 -1 -1 -1
+@testcase | 113 | 0 | 1
@fif_codegen
"""
simpleAllConst PROC:<{
//
- -1 PUSHINT
- 0 PUSHINT
- -1 PUSHINT
- 0 PUSHINT
- -1 PUSHINT
+ TRUE
0 PUSHINT
- -1 PUSHINT
+ TRUE
+ FALSE
+ TRUE
+ FALSE
+ TRUE
TRUE
TRUE
}>
@@ -292,4 +321,27 @@ These are moments of future optimizations. For now, it's more than enough.
}>
"""
+@fif_codegen
+"""
+ testConvertIfToIfnot PROC:<{
+ // x
+ DUP // x x
+ 100 THROWIF
+ DUP // x x
+ 100 THROWIF
+ DUP // x x
+ IFNOTJMP:<{ // x
+ DROP //
+ 1 PUSHINT // _7=1
+ }> // x
+ DUP // x x
+ IFNOTJMP:<{ // x
+ DROP //
+ 1 PUSHINT // _8=1
+ }> // x
+ 100 THROWIFNOT
+ -4 PUSHINT // _12=-4
+ }>
+"""
+
*/
diff --git a/tolk-tester/tests/mutate-methods.tolk b/tolk-tester/tests/mutate-methods.tolk
index b9184ca9a..816e4c8d2 100644
--- a/tolk-tester/tests/mutate-methods.tolk
+++ b/tolk-tester/tests/mutate-methods.tolk
@@ -118,12 +118,19 @@ fun updateTwoItems(mutate self: (int, int), byValue: int) {
self = (first + byValue, second + byValue);
}
+global t107_1: int;
+global t107_2: int;
+
@method_id(107)
fun testMutableTensor() {
var t = (40, 50);
t.updateTwoItems(10);
updateTwoItems(mutate t, 10);
- return t;
+ t107_1 = 1;
+ t107_2 = 2;
+ (t107_1, t107_2).updateTwoItems(10);
+ updateTwoItems(mutate (t107_1, t107_2), 10);
+ return (t, t107_1, t107_2);
}
@pure
@@ -147,7 +154,7 @@ fun getSumOfNumbersInCell(c: cell): int {
@method_id(110)
fun testStoreChaining() {
- var b = beginCell().storeUint(1, 32).storeUint(2, 32).storeUint(3, 32);
+ var b = ((beginCell()).storeUint(1, 32)).storeUint(2, 32).storeUint(3, 32);
b.storeUint(4, 32);
b.myStoreUint(5, 32).storeUint(6, 32);
storeUint(mutate b, 7, 32);
@@ -191,7 +198,7 @@ fun testStoreAndMutateBoth() {
b.myStoreU32_and_mutate_x(mutate x);
var cs: slice = b.endCell().beginParse();
- var (n1,n2,n3,n4,n5) = (cs.loadUint(32),cs.loadUint(32),cs.loadUint(32),cs.loadUint(32),cs.loadUint(32));
+ var (n1,n2,n3,n4,n5) = (cs.loadUint(32),((cs)).loadUint(32),cs.loadUint(32),cs.loadUint(32),cs.loadUint(32));
assert(n5 == x) throw 100;
return [n1,n2,n3,n4,n5];
@@ -278,7 +285,7 @@ fun main(){}
@testcase | 104 | | 1 2 3
@testcase | 105 | | 5 5 110
@testcase | 106 | | 160 110
-@testcase | 107 | | 60 70
+@testcase | 107 | | 60 70 21 22
@testcase | 110 | | 320
@testcase | 111 | | 55 55
@testcase | 112 | | [ 1 13 3 23 33 ]
@@ -300,7 +307,7 @@ fun main(){}
...
incrementTwoInPlace CALLDICT // x y sum1
-ROT
- 10 PUSHINT // sum1 x y _9=10
+ 10 PUSHINT // sum1 x y _8=10
incrementTwoInPlace CALLDICT // sum1 x y sum2
s1 s3 s0 XCHG3 // x y sum1 sum2
}>
@@ -310,8 +317,8 @@ fun main(){}
"""
load_next PROC:<{
// cs
- 32 LDI // _1 cs
- SWAP // cs _1
+ 32 LDI // _3 cs
+ SWAP // cs _3
}>
"""
@@ -319,7 +326,7 @@ fun main(){}
"""
testStoreUintPureUnusedResult PROC:<{
//
- 0 PUSHINT // _12=0
+ 0 PUSHINT // _11=0
}>
"""
@@ -330,7 +337,7 @@ fun main(){}
NEWC // b
STIX // _2
DROP //
- 0 PUSHINT // _12=0
+ 0 PUSHINT // _11=0
}>
"""
diff --git a/tolk-tester/tests/no-spaces.tolk b/tolk-tester/tests/no-spaces.tolk
index 0d4c3b678..da7338989 100644
--- a/tolk-tester/tests/no-spaces.tolk
+++ b/tolk-tester/tests/no-spaces.tolk
@@ -22,7 +22,7 @@ global `some()var`:int;
return `a`*-1*-(1)*---(1)*+just10()+-`just10`()*m1*-m1+-eq(m1)----0x1;
}
-@method_id(112) fun `bitwise~ops`(flags:int):[int,int] {
+@method_id(112) fun `bitwise~ops`(flags:int):[bool,bool] {
return[
(just10()-3==just10()-(4)--1)|((2==2)&(eq(eq(10)) -3==just10()--13)),
((flags&0xFF)!=0)
diff --git a/tolk-tester/tests/null-keyword.tolk b/tolk-tester/tests/null-keyword.tolk
index cdfe5acf9..9ace99956 100644
--- a/tolk-tester/tests/null-keyword.tolk
+++ b/tolk-tester/tests/null-keyword.tolk
@@ -7,12 +7,14 @@ fun test1() {
numbers = listPrepend(2, numbers);
numbers = listPrepend(3, numbers);
numbers = listPrepend(4, numbers);
- var (h, numbers redef) = listSplit(numbers);
+ var (h: int, numbers redef) = listSplit(numbers);
h += listGetHead(numbers);
+ _ = null;
+ (_, _) = (null, null);
var t = createEmptyTuple();
do {
- var num = numbers.listNext();
+ var num: int = numbers.listNext();
t.tuplePush(num);
} while (numbers != null);
@@ -44,7 +46,7 @@ fun test3(x: int) {
}
fun getUntypedNull() {
- var untyped = null;
+ var untyped: null = null;
if (true) {
return untyped;
}
@@ -52,8 +54,8 @@ fun getUntypedNull() {
}
@method_id(104)
-fun test4() {
- var (_, (_, untyped)) = (3, (createEmptyTuple, null));
+fun test4(): null {
+ var (_, (_, untyped: null)) = (3, (createEmptyTuple, null));
if (true) {
return untyped;
}
@@ -62,21 +64,16 @@ fun test4() {
@method_id(105)
fun test5() {
- var n = getUntypedNull();
+ var n: slice = getUntypedNull();
return !(null == n) ? n.loadInt(32) : 100;
}
-@method_id(106)
-fun test6(x: int) {
- return x > null; // this compiles (for now), but fails at runtime
-}
-
@method_id(107)
fun test7() {
var b = beginCell().storeMaybeRef(null);
var s = b.endCell().beginParse();
var c = s.loadMaybeRef();
- return (null == c) * 10 + (b != null);
+ return (null == c) as int * 10 + (b != null) as int;
}
fun main() {
@@ -132,27 +129,18 @@ fun main() {
}>
"""
-@fif_codegen
-"""
- test6 PROC:<{
- // x
- PUSHNULL // x _1
- GREATER // _2
- }>
-"""
-
@fif_codegen
"""
test7 PROC:<{
...
- LDOPTREF // b _20 _19
+ LDOPTREF // b _18 _17
DROP // b c
- ISNULL // b _13
- 10 MULCONST // b _15
- SWAP // _15 b
- ISNULL // _15 _16
- 0 EQINT // _15 _17
- ADD // _18
+ ISNULL // b _11
+ 10 MULCONST // b _13
+ SWAP // _13 b
+ ISNULL // _13 _14
+ NOT // _13 _15
+ ADD // _16
}>
"""
*/
diff --git a/tolk-tester/tests/op_priority.tolk b/tolk-tester/tests/op-priority.tolk
similarity index 73%
rename from tolk-tester/tests/op_priority.tolk
rename to tolk-tester/tests/op-priority.tolk
index e4f97b759..8a57b3940 100644
--- a/tolk-tester/tests/op_priority.tolk
+++ b/tolk-tester/tests/op-priority.tolk
@@ -1,4 +1,4 @@
-fun justTrue(): int { return true; }
+fun justTrue(): bool { return true; }
fun unary_minus_1(a: int, b: int, c: int): int{return -(a+b) *c;}
fun unary_minus_2(a: int, b: int, c: int): int{return(-(a+b))*c;}
@@ -6,17 +6,17 @@ fun unary_minus_3(a: int, b: int, c: int): int{return-((a+b) *c);}
@method_id(101)
-fun test1(x: int, y: int, z: int): int {
+fun test1(x: int, y: int, z: int): bool {
return (x > 0) & (y > 0) & (z > 0);
}
@method_id(102)
-fun test2(x: int, y: int, z: int): int {
- return x > (0 & (y > 0) & (z > 0));
+fun test2(x: int, y: int, z: int): bool {
+ return x > (0 & (y > 0) as int & (z > 0) as int);
}
@method_id(103)
-fun test3(x: int, y: int, z: int): int {
+fun test3(x: int, y: int, z: int): bool {
if ((x < 0) | (y < 0)) {
return z < 0;
}
@@ -24,29 +24,29 @@ fun test3(x: int, y: int, z: int): int {
}
@method_id(104)
-fun test4(x: int, y: int, mode: int): int {
+fun test4(x: int, y: int, mode: int): bool {
if (mode == 1) {
return (x == 10) | (y == 20);
} if (mode == 2) {
return (x == 10) | (y == 20);
} else {
- return x == (10 | (y == 20));
+ return x == (10 | (y == 20) as int);
}
}
@method_id(105)
-fun test5(status: int): int {
- return justTrue() & (status == 1) & ((justTrue() & status) == 1);
+fun test5(status: int): bool {
+ return justTrue() & (status == 1) & ((justTrue() as int & status) == 1);
}
@method_id(106)
-fun test6(a: int, b: int, c: int): int {
+fun test6(a: int, b: int, c: int): bool {
return (unary_minus_1(a,b,c) == unary_minus_2(a,b,c)) & (unary_minus_1(a,b,c) == unary_minus_3(a,b,c));
}
@method_id(107)
fun test7(b: int): int {
- var a = b == 3 ? 3 : b == 4 ? 4 : (b == 5) & 1 ? 5 : 100;
+ var a = b == 3 ? 3 : b == 4 ? 4 : (b == 5) & true ? 5 : 100;
return a;
}
@@ -56,14 +56,14 @@ fun test8(b: int): int {
return a;
}
-fun `_<p`(a: auto, b: auto): int { return true; }
+fun `_<p`(a: int, b: int): bool { return true; }
fun main() {
// ok to parse
var c = [
- (3 & 3) > 0, 3 & (3 > 0), 3 & (`_<_`(3, 0)),
- 3 & `_<p`(3, 0), (1 & 2) ^ (3 | 4),
- 1 & ((1) == 1)
+ (3 & 3) > 0, 3 & (3 > 0) as int, 3 & (`_<_`(3, 0)),
+ 3 & `_<p`(3, 0) as int, (1 & 2) ^ (3 | 4),
+ true & ((1) == 1)
];
}
diff --git a/tolk-tester/tests/pure-functions.tolk b/tolk-tester/tests/pure-functions.tolk
index 8598e85c2..bb1a7d593 100644
--- a/tolk-tester/tests/pure-functions.tolk
+++ b/tolk-tester/tests/pure-functions.tolk
@@ -32,7 +32,7 @@ fun test1(): int {
@method_id(102)
fun test2(value: int): int {
save_contract_data(value);
- var (_, restored: auto) = get_contract_data();
+ var (_, restored) = get_contract_data();
return restored;
}
diff --git a/tolk-tester/tests/remove-unused-functions.tolk b/tolk-tester/tests/remove-unused-functions.tolk
index e5d8aabcb..8e748ecf1 100644
--- a/tolk-tester/tests/remove-unused-functions.tolk
+++ b/tolk-tester/tests/remove-unused-functions.tolk
@@ -10,9 +10,9 @@ fun used_from_noncall2(): int { return int20; }
fun used_as_noncall2(): int { return 0 * 0 + used_from_noncall2() + (0 << 0); }
global unused_gv: int;
-global used_gv: auto;
+global used_gv: int;
-fun receiveGetter(): (() -> int) { return used_as_noncall2; }
+fun receiveGetter(): () -> int { return used_as_noncall2; }
@pure
fun usedButOptimizedOut(x: int): int { return x + 2; }
diff --git a/tolk-tester/tests/self-keyword.tolk b/tolk-tester/tests/self-keyword.tolk
index a339e7d01..b0567696d 100644
--- a/tolk-tester/tests/self-keyword.tolk
+++ b/tolk-tester/tests/self-keyword.tolk
@@ -158,6 +158,44 @@ fun testNotMutatingChainableSelfMutateAnother(initial: int) {
return (arg, c108, c109, x);
}
+fun pickG110(mutate self: int, mutate pushTo: tuple): self {
+ self += 10;
+ pushTo.tuplePush(c110);
+ return self;
+}
+
+global tup110: tuple;
+global c110: int;
+
+@method_id(110)
+fun testMutateGlobalsLValue(init: int) {
+ c110 = init;
+ tup110 = createEmptyTuple();
+ c110.incChained().incChained().pickG110(mutate tup110).incChained().pickG110(mutate tup110).incChained();
+ return (c110, tup110);
+}
+
+fun myTuplePush<T>(mutate self: tuple, value: T): self {
+ self.tuplePush(value);
+ return self;
+}
+
+fun myTupleAt<T>(self: tuple, idx: int): T {
+ return self.tupleAt(idx);
+}
+
+global tup111: tuple;
+
+@method_id(111)
+fun testForallFunctionsWithSelf(): (int, int, tuple) {
+ var t = createEmptyTuple();
+ tup111 = createEmptyTuple();
+ t.myTuplePush(10);
+ tup111.myTuplePush(1).myTuplePush(2).myTuplePush(3);
+ return (t.myTupleAt(0), tup111.myTupleAt(tup111.tupleSize() - 1), tup111);
+}
+
+
fun main() { }
@@ -179,6 +217,8 @@ fun main() { }
@testcase | 109 | 200 | 200 3 1 2
@testcase | 109 | 100 | 100 0 0 1
@testcase | 109 | 102 | 102 2 1 2
+@testcase | 110 | 0 | 24 [ 2 13 ]
+@testcase | 111 | | 10 3 [ 1 2 3 ]
@fif_codegen
"""
diff --git a/tolk-tester/tests/test-math.tolk b/tolk-tester/tests/test-math.tolk
index 893035fde..6b147c776 100644
--- a/tolk-tester/tests/test-math.tolk
+++ b/tolk-tester/tests/test-math.tolk
@@ -218,7 +218,7 @@ fun fixed248_log2_const(): int {
@pure
@inline
fun Pi_const_f254(): int {
- var (c: auto, _) = Pi_xconst_f254();
+ var (c, _) = Pi_xconst_f254();
return c;
}
@@ -661,7 +661,7 @@ fun fixed248_pow(x: int, y: int): int {
return 1 << 248; // x^0 = 1
}
if (x <= 0) {
- var bad: int = (x | y) < 0;
+ var bad: int = ((x | y) < 0) as int;
return 0 >> bad; // 0^y = 0 if x=0 and y>=0; "out of range" exception otherwise
}
var (l, s) = log2_aux_f256(x);
@@ -677,7 +677,7 @@ fun fixed248_pow(x: int, y: int): int {
// now log_2(x^y) = y*log_2(x) = q + ll, ss integer, ll fixed257, -1/2<=ll<1/2
var sq: int = q + 248;
if (sq <= 0) {
- return -(sq == 0); // underflow
+ return -((sq == 0) as int); // underflow
}
y = expm1_f257(mulrshiftr256(ll, log2_const_f256()));
return (y ~>> (9 - q)) - (-1 << sq);
@@ -986,7 +986,7 @@ fun tset<X>(mutate self: tuple, idx: int, value: X): void
// fixed256 acos_prepare_slow(fixed255 x);
@inline
fun acos_prepare_slow_f255(x: int): int {
- x -= (x == 0);
+ x -= (x == 0) as int;
var t: int = 1;
repeat (255) {
t = t * sign(x) * 2 + 1; // decode Gray code (sign(x_0), sign(x_1), ...)
@@ -1019,7 +1019,8 @@ fun test_nrand(n: int): tuple {
repeat (n) {
var x: int = fixed248_nrand();
var bucket: int = (abs(x) >> 243); // 255 buckets starting from x=0, each 1/32 wide
- t.tset(bucket, t.tupleAt(bucket) + 1);
+ var at_bucket: int = t.tupleAt(bucket);
+ t.tset(bucket, at_bucket + 1);
}
return t;
}
diff --git a/tolk-tester/tests/try-func.tolk b/tolk-tester/tests/try-func.tolk
index 7963a8500..dfd72e9e9 100644
--- a/tolk-tester/tests/try-func.tolk
+++ b/tolk-tester/tests/try-func.tolk
@@ -1,7 +1,3 @@
-fun unsafeGetInt<X>(any: X): int
- asm "NOP";
-
-@method_id(11)
fun foo(x: int): int {
try {
if (x == 7) {
@@ -14,7 +10,6 @@ fun foo(x: int): int {
}
@inline
-@method_id(12)
fun foo_inline(x: int): int {
try {
assert(!(x == 7)) throw 44;
@@ -25,36 +20,34 @@ fun foo_inline(x: int): int {
}
@inline_ref
-@method_id(13)
fun foo_inlineref(x: int): int {
try {
if (x == 7) { throw (44, 2); }
return x;
} catch (_, arg) {
- return unsafeGetInt(arg);
+ return arg as int;
}
}
-@method_id(1)
+@method_id(101)
fun test(x: int, y: int, z: int): int {
y = foo(y);
return x * 100 + y * 10 + z;
}
-@method_id(2)
+@method_id(102)
fun test_inline(x: int, y: int, z: int): int {
y = foo_inline(y);
return x * 100 + y * 10 + z;
}
-@method_id(3)
+@method_id(103)
fun test_inlineref(x: int, y: int, z: int): int {
y = foo_inlineref(y);
return x * 100 + y * 10 + z;
}
@inline
-@method_id(14)
fun foo_inline_big(
x1: int, x2: int, x3: int, x4: int, x5: int, x6: int, x7: int, x8: int, x9: int, x10: int,
x11: int, x12: int, x13: int, x14: int, x15: int, x16: int, x17: int, x18: int, x19: int, x20: int
@@ -69,7 +62,7 @@ fun foo_inline_big(
}
}
-@method_id(4)
+@method_id(104)
fun test_inline_big(x: int, y: int, z: int): int {
y = foo_inline_big(
y, y + 1, y + 2, y + 3, y + 4, y + 5, y + 6, y + 7, y + 8, y + 9,
@@ -77,7 +70,6 @@ fun test_inline_big(x: int, y: int, z: int): int {
return x * 1000000 + y * 1000 + z;
}
-@method_id(15)
fun foo_big(
x1: int, x2: int, x3: int, x4: int, x5: int, x6: int, x7: int, x8: int, x9: int, x10: int,
x11: int, x12: int, x13: int, x14: int, x15: int, x16: int, x17: int, x18: int, x19: int, x20: int
@@ -88,11 +80,11 @@ fun foo_big(
}
return x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 + x11 + x12 + x13 + x14 + x15 + x16 + x17 + x18 + x19 + x20;
} catch (code, arg) {
- return unsafeGetInt(arg);
+ return arg as int;
}
}
-@method_id(5)
+@method_id(105)
fun test_big(x: int, y: int, z: int): int {
y = foo_big(
y, y + 1, y + 2, y + 3, y + 4, y + 5, y + 6, y + 7, y + 8, y + 9,
@@ -100,7 +92,7 @@ fun test_big(x: int, y: int, z: int): int {
return x * 1000000 + y * 1000 + z;
}
-@method_id(16)
+@method_id(106)
fun test_catch_into_same(x: int): int {
var code = x;
try {
@@ -112,7 +104,7 @@ fun test_catch_into_same(x: int): int {
}
-@method_id(17)
+@method_id(107)
fun test_catch_into_same_2(x: int): int {
var code = x;
try {
@@ -124,28 +116,77 @@ fun test_catch_into_same_2(x: int): int {
return code;
}
+global after046: int;
+
+// this bug existed in FunC and is fixed in v0.4.6
+fun bug_046_internal(op: int) {
+ if (op == 1) {
+ return;
+ } else if (op == 2) {
+ return;
+ } else {
+ throw 1;
+ }
+}
+
+fun bug_046_called() {
+ after046 = 0;
+ try {
+ bug_046_internal(1337);
+ after046 = 1; // shouldn't be called
+ } catch(n) {
+ return;
+ }
+ return;
+}
+
+@method_id(108)
+fun bug_046_entrypoint() {
+ bug_046_called();
+ return after046;
+}
+
+global g_reg: int;
+
+@method_id(109)
+fun test109(): (int, int) {
+ var l_reg = 10;
+ g_reg = 10;
+ try {
+ // note, that regardless of assignment, an exception RESTORES them to previous (to 10)
+ // it's very unexpected, but is considered to be a TVM feature, not a bug
+ g_reg = 999;
+ l_reg = 999;
+ bug_046_internal(999); // throws
+ } catch {
+ }
+ // returns (10,10) because of an exception, see a comment above
+ return (g_reg, l_reg);
+}
+
fun main() {
}
/**
- method_id | in | out
-@testcase | 1 | 1 2 3 | 123
-@testcase | 1 | 3 8 9 | 389
-@testcase | 1 | 3 7 9 | 329
-@testcase | 2 | 1 2 3 | 123
-@testcase | 2 | 3 8 9 | 389
-@testcase | 2 | 3 7 9 | 329
-@testcase | 3 | 1 2 3 | 123
-@testcase | 3 | 3 8 9 | 389
-@testcase | 3 | 3 7 9 | 329
-@testcase | 4 | 4 8 9 | 4350009
-@testcase | 4 | 4 7 9 | 4001009
-@testcase | 5 | 4 8 9 | 4350009
-@testcase | 5 | 4 7 9 | 4001009
-@testcase | 16 | 5 | 5
-@testcase | 16 | 20 | 44
-@testcase | 17 | 5 | 5
-@testcase | 17 | 20 | 20
-
-@code_hash 73240939343624734070640372352271282883450660826541545137654364443860257436623
+ method_id | in | out
+@testcase | 101 | 1 2 3 | 123
+@testcase | 101 | 3 8 9 | 389
+@testcase | 101 | 3 7 9 | 329
+@testcase | 102 | 1 2 3 | 123
+@testcase | 102 | 3 8 9 | 389
+@testcase | 102 | 3 7 9 | 329
+@testcase | 103 | 1 2 3 | 123
+@testcase | 103 | 3 8 9 | 389
+@testcase | 103 | 3 7 9 | 329
+@testcase | 104 | 4 8 9 | 4350009
+@testcase | 104 | 4 7 9 | 4001009
+@testcase | 105 | 4 8 9 | 4350009
+@testcase | 105 | 4 7 9 | 4001009
+@testcase | 106 | 5 | 5
+@testcase | 106 | 20 | 44
+@testcase | 107 | 5 | 5
+@testcase | 107 | 20 | 20
+@testcase | 108 | | 0
+
+@code_hash 39307974281105539319288356721945232226028429128341177951717392648324358675585
*/
diff --git a/tolk-tester/tests/unbalanced_ret_loops.tolk b/tolk-tester/tests/unbalanced_ret_loops.tolk
index 9b59339d8..292b48dac 100644
--- a/tolk-tester/tests/unbalanced_ret_loops.tolk
+++ b/tolk-tester/tests/unbalanced_ret_loops.tolk
@@ -38,7 +38,7 @@ fun foo_until(x: int): int {
}
@method_id(4)
-fun test4(x: int): (int, int) {
+fun test4(x: int): (int, bool) {
var s = 0;
var reached = false;
do {
diff --git a/tolk-tester/tests/unreachable-1.tolk b/tolk-tester/tests/unreachable-1.tolk
new file mode 100644
index 000000000..5b3cb1b01
--- /dev/null
+++ b/tolk-tester/tests/unreachable-1.tolk
@@ -0,0 +1,14 @@
+fun main(x: int) {
+ if (x) {
+ x = 10;;;;;
+ return x;;;
+ x = 20;
+ }
+ return -1;
+}
+
+/**
+@testcase | 0 | 1 | 10
+@stderr warning: unreachable code
+@stderr x = 20;
+ */
diff --git a/tolk-tester/tests/unreachable-2.tolk b/tolk-tester/tests/unreachable-2.tolk
new file mode 100644
index 000000000..aeadd8c64
--- /dev/null
+++ b/tolk-tester/tests/unreachable-2.tolk
@@ -0,0 +1,22 @@
+fun main(x: int) {
+ if (x) {
+ if (x > 10) {
+ return 1; // throw 1;
+ } else if (true) {
+ return -1;
+ } else {
+ return 2; // throw 2;
+ }
+ } else {
+ {{return 1;}
+ x = 30;}
+ }
+ assert(false, 10);
+}
+
+/**
+@testcase | 0 | 1 | -1
+@stderr warning: unreachable code
+@stderr assert(false, 10)
+@stderr x = 30
+ */
diff --git a/tolk-tester/tests/var-apply.tolk b/tolk-tester/tests/var-apply.tolk
index 9bee862ac..a0918c181 100644
--- a/tolk-tester/tests/var-apply.tolk
+++ b/tolk-tester/tests/var-apply.tolk
@@ -15,8 +15,127 @@ fun testVarApply1() {
return (s.loadInt(32), s.loadInt(32));
}
+@inline
+fun my_throw_always() {
+ throw 1000;
+}
+
+@inline
+fun get_raiser() {
+ return my_throw_always;
+}
+
+@method_id(102)
+fun testVarApplyWithoutSavingResult() {
+ try {
+ var raiser = get_raiser();
+ raiser(); // `some_var()` is always impure, the compiler has no considerations about its runtime value
+ return 0;
+ } catch (code) {
+ return code;
+ }
+}
+
+@inline
+fun sum(a: int, b: int) {
+ assert(a + b < 24, 1000);
+ return a + b;
+}
+
+@inline
+fun mul(a: int, b: int) {
+ assert(a * b < 24, 1001);
+ return a * b;
+}
+
+fun demo_handler(op: int, query_id: int, a: int, b: int): int {
+ if (op == 0xF2) {
+ val func = query_id % 2 == 0 ? sum : mul;
+ val result = func(a, b);
+ return 0; // result not used, we test that func is nevertheless called
+ }
+ if (op == 0xF4) {
+ val func = query_id % 2 == 0 ? sum : mul;
+ val result = func(a, b);
+ return result;
+ }
+ return -1;
+}
+
+@method_id(103)
+fun testVarApplyInTernary() {
+ var t: tuple = createEmptyTuple();
+ try {
+ t.tuplePush(demo_handler(0xF2, 122, 100, 200));
+ } catch(code) {
+ t.tuplePush(code);
+ }
+ try {
+ t.tuplePush(demo_handler(0xF4, 122, 100, 200));
+ } catch(code) {
+ t.tuplePush(code);
+ }
+ try {
+ t.tuplePush(demo_handler(0xF2, 122, 10, 10));
+ } catch(code) {
+ t.tuplePush(code);
+ }
+ try {
+ t.tuplePush(demo_handler(0xF2, 123, 10, 10));
+ } catch(code) {
+ t.tuplePush(code);
+ }
+ return t;
+}
+
+fun always_throw2(x: int) {
+ throw 239 + x;
+}
+
+global global_f: int -> void;
+
+@method_id(104)
+fun testGlobalVarApply() {
+ try {
+ global_f = always_throw2;
+ global_f(1);
+ return 0;
+ } catch (code) {
+ return code;
+ }
+}
+
+@method_id(105)
+fun testVarApply2() {
+ var creator = createEmptyTuple;
+ var t = creator();
+ t.tuplePush(1);
+ var sizer = t.tupleSize;
+ return sizer(t);
+}
+
+fun getTupleLastGetter<X>(): (tuple) -> X {
+ return tupleLast<X>;
+}
+
+@method_id(106)
+fun testVarApply3() {
+ var t = createEmptyTuple();
+ t.tuplePush(1);
+ t.tuplePush([2]);
+ var getIntAt = t.tupleAt<int>;
+ var getTupleFirstInt = createEmptyTuple().tupleFirst<int>;
+ var getTupleLastTuple = getTupleLastGetter<tuple>();
+ return (getIntAt(t, 0), getTupleFirstInt(t), getTupleLastTuple(t), getTupleLastGetter<tuple>()(t));
+}
+
fun main() {}
/**
@testcase | 101 | | 1 2
+@testcase | 102 | | 1000
+@testcase | 103 | | [ 1000 1000 0 1001 ]
+@testcase | 104 | | 240
+@testcase | 105 | | 1
+@testcase | 106 | | 1 1 [ 2 ] [ 2 ]
*/
diff --git a/tolk-tester/tests/w6.tolk b/tolk-tester/tests/w6.tolk
index 2f8956440..489ffa8cc 100644
--- a/tolk-tester/tests/w6.tolk
+++ b/tolk-tester/tests/w6.tolk
@@ -6,7 +6,7 @@ fun main(x: int): int {
if (i > 5) {
return 1;
}
- var f: int = (i * i == 64);
+ var f: bool = (i * i == 64);
} while (!f);
return -1;
}
diff --git a/tolk-tester/tests/w7.tolk b/tolk-tester/tests/w7.tolk
index 85081fbb3..3d68c775b 100644
--- a/tolk-tester/tests/w7.tolk
+++ b/tolk-tester/tests/w7.tolk
@@ -4,7 +4,7 @@ fun test(y: int): int {
if (y > 0) {
return 1;
}
- return x > 0;
+ return x > 0 ? -1 : 0;
}
@method_id(2)
diff --git a/tolk-tester/tolk-tester.js b/tolk-tester/tolk-tester.js
index 2a3eb776a..c7e710214 100644
--- a/tolk-tester/tolk-tester.js
+++ b/tolk-tester/tolk-tester.js
@@ -347,11 +347,11 @@ class TolkTestFile {
if (exit_code === 0 && this.compilation_should_fail)
throw new TolkCompilationSucceededError("compilation succeeded, but it should have failed")
- if (exit_code !== 0 && this.compilation_should_fail) {
- for (let should_include of this.stderr_includes)
- should_include.check(stderr)
+ for (let should_include of this.stderr_includes) // @stderr is used to check errors and warnings
+ should_include.check(stderr)
+
+ if (exit_code !== 0 && this.compilation_should_fail)
return
- }
if (exit_code !== 0 && !this.compilation_should_fail)
throw new TolkCompilationFailedError(`tolk exit_code = ${exit_code}`, stderr)
diff --git a/tolk-tester/tolk-tester.py b/tolk-tester/tolk-tester.py
index 261ab4962..0b3c774ca 100644
--- a/tolk-tester/tolk-tester.py
+++ b/tolk-tester/tolk-tester.py
@@ -327,9 +327,10 @@ def run_and_check(self):
if exit_code == 0 and self.compilation_should_fail:
raise TolkCompilationSucceededError("compilation succeeded, but it should have failed")
+ for should_include in self.stderr_includes: # @stderr is used to check errors and warnings
+ should_include.check(stderr)
+
if exit_code != 0 and self.compilation_should_fail:
- for should_include in self.stderr_includes:
- should_include.check(stderr)
return
if exit_code != 0 and not self.compilation_should_fail:
diff --git a/tolk/CMakeLists.txt b/tolk/CMakeLists.txt
index d2decea71..9d7200249 100644
--- a/tolk/CMakeLists.txt
+++ b/tolk/CMakeLists.txt
@@ -7,14 +7,24 @@ set(TOLK_SOURCE
compiler-state.cpp
ast.cpp
ast-from-tokens.cpp
+ constant-evaluator.cpp
pipe-discover-parse-sources.cpp
pipe-register-symbols.cpp
+ pipe-resolve-identifiers.cpp
+ pipe-calc-rvalue-lvalue.cpp
+ pipe-detect-unreachable.cpp
+ pipe-infer-types-and-calls.cpp
+ pipe-refine-lvalue-for-mutate.cpp
+ pipe-check-rvalue-lvalue.cpp
+ pipe-check-pure-impure.cpp
+ pipe-constant-folding.cpp
+ pipe-optimize-boolean-expr.cpp
pipe-ast-to-legacy.cpp
pipe-find-unused-symbols.cpp
pipe-generate-fif-output.cpp
- unify-types.cpp
+ type-system.cpp
+ generics-helpers.cpp
abscode.cpp
- gen-abscode.cpp
analyzer.cpp
asmops.cpp
builtins.cpp
diff --git a/tolk/abscode.cpp b/tolk/abscode.cpp
index c1add6839..7bcb0f84f 100644
--- a/tolk/abscode.cpp
+++ b/tolk/abscode.cpp
@@ -16,6 +16,7 @@
*/
#include "tolk.h"
#include "compiler-state.h"
+#include "type-system.h"
namespace tolk {
@@ -25,21 +26,10 @@ namespace tolk {
*
*/
-TmpVar::TmpVar(var_idx_t _idx, TypeExpr* _type, sym_idx_t sym_idx, SrcLocation loc)
- : v_type(_type), idx(_idx), sym_idx(sym_idx), coord(0), where(loc) {
- if (!_type) {
- v_type = TypeExpr::new_hole();
- }
-}
-
-void TmpVar::set_location(SrcLocation loc) {
- where = loc;
-}
-
void TmpVar::dump(std::ostream& os) const {
show(os);
os << " : " << v_type << " (width ";
- v_type->show_width(os);
+ os << v_type->calc_width_on_stack();
os << ")";
if (coord > 0) {
os << " = _" << (coord >> 8) << '.' << (coord & 255);
@@ -55,8 +45,8 @@ void TmpVar::dump(std::ostream& os) const {
}
void TmpVar::show(std::ostream& os, int omit_idx) const {
- if (!is_unnamed()) {
- os << G.symbols.get_name(sym_idx);
+ if (v_sym) {
+ os << v_sym->name;
if (omit_idx >= 2) {
return;
}
@@ -149,10 +139,6 @@ void VarDescr::set_const(std::string value) {
val = _Const;
}
-void VarDescr::set_const_nan() {
- set_const(td::make_refint());
-}
-
void VarDescr::operator|=(const VarDescr& y) {
val &= y.val;
if (is_int_const() && y.is_int_const() && cmp(int_const, y.int_const) != 0) {
@@ -273,7 +259,7 @@ void Op::show(std::ostream& os, const std::vector<TmpVar>& vars, std::string pfx
case _Call:
os << pfx << dis << "CALL: ";
show_var_list(os, left, vars);
- os << " := " << (fun_ref ? fun_ref->name() : "(null)") << " ";
+ os << " := " << (f_sym ? f_sym->name : "(null)") << " ";
if ((mode & 4) && args.size() == right.size()) {
show_var_list(os, args, vars);
} else {
@@ -332,11 +318,11 @@ void Op::show(std::ostream& os, const std::vector<TmpVar>& vars, std::string pfx
case _GlobVar:
os << pfx << dis << "GLOBVAR ";
show_var_list(os, left, vars);
- os << " := " << (fun_ref ? fun_ref->name() : "(null)") << std::endl;
+ os << " := " << (g_sym ? g_sym->name : "(null)") << std::endl;
break;
case _SetGlob:
os << pfx << dis << "SETGLOB ";
- os << (fun_ref ? fun_ref->name() : "(null)") << " := ";
+ os << (g_sym ? g_sym->name : "(null)") << " := ";
show_var_list(os, right, vars);
os << std::endl;
break;
@@ -458,22 +444,22 @@ void CodeBlob::print(std::ostream& os, int flags) const {
os << "-------- END ---------\n\n";
}
-var_idx_t CodeBlob::create_var(TypeExpr* var_type, var_idx_t sym_idx, SrcLocation location) {
- vars.emplace_back(var_cnt, var_type, sym_idx, location);
+var_idx_t CodeBlob::create_var(TypePtr var_type, const LocalVarData* v_sym, SrcLocation location) {
+ vars.emplace_back(var_cnt, var_type, v_sym, location);
return var_cnt++;
}
-bool CodeBlob::import_params(FormalArgList arg_list) {
+bool CodeBlob::import_params(FormalArgList&& arg_list) {
if (var_cnt || in_var_cnt) {
return false;
}
std::vector<var_idx_t> list;
for (const auto& par : arg_list) {
- TypeExpr* arg_type;
- SymDef* arg_sym;
+ TypePtr arg_type;
+ const LocalVarData* arg_sym;
SrcLocation arg_loc;
std::tie(arg_type, arg_sym, arg_loc) = par;
- list.push_back(create_var(arg_type, arg_sym ? arg_sym->sym_idx : 0, arg_loc));
+ list.push_back(create_var(arg_type, arg_sym, arg_loc));
}
emplace_back(loc, Op::_Import, list);
in_var_cnt = var_cnt;
diff --git a/tolk/analyzer.cpp b/tolk/analyzer.cpp
index 719df9b7d..8539afdd2 100644
--- a/tolk/analyzer.cpp
+++ b/tolk/analyzer.cpp
@@ -16,6 +16,7 @@
*/
#include "tolk.h"
#include "compiler-state.h"
+#include "type-system.h"
namespace tolk {
@@ -25,38 +26,30 @@ namespace tolk {
*
*/
-void CodeBlob::simplify_var_types() {
- for (TmpVar& var : vars) {
- TypeExpr::remove_indirect(var.v_type);
- var.v_type->recompute_width();
- }
-}
-
int CodeBlob::split_vars(bool strict) {
int n = var_cnt, changes = 0;
for (int j = 0; j < var_cnt; j++) {
TmpVar& var = vars[j];
- if (strict && var.v_type->minw != var.v_type->maxw) {
+ int width_j = var.v_type->calc_width_on_stack();
+ if (strict && width_j < 0) {
throw ParseError{var.where, "variable does not have fixed width, cannot manipulate it"};
}
- std::vector<TypeExpr*> comp_types;
- int k = var.v_type->extract_components(comp_types);
- tolk_assert(k <= 254 && n <= 0x7fff00);
- tolk_assert((unsigned)k == comp_types.size());
- if (k != 1) {
- var.coord = ~((n << 8) + k);
- for (int i = 0; i < k; i++) {
- auto v = create_var(comp_types[i], vars[j].sym_idx, vars[j].where);
- tolk_assert(v == n + i);
- tolk_assert(vars[v].idx == v);
- vars[v].coord = ((int)j << 8) + i + 1;
- }
- n += k;
- ++changes;
- } else if (strict && var.v_type->minw != 1) {
- throw ParseError{var.where,
- "cannot work with variable or variable component of width greater than one"};
+ if (width_j == 1) {
+ continue;
}
+ std::vector<TypePtr> comp_types;
+ var.v_type->extract_components(comp_types);
+ tolk_assert(width_j <= 254 && n <= 0x7fff00);
+ tolk_assert((unsigned)width_j == comp_types.size());
+ var.coord = ~((n << 8) + width_j);
+ for (int i = 0; i < width_j; i++) {
+ auto v = create_var(comp_types[i], vars[j].v_sym, vars[j].where);
+ tolk_assert(v == n + i);
+ tolk_assert(vars[v].idx == v);
+ vars[v].coord = ((int)j << 8) + i + 1;
+ }
+ n += width_j;
+ ++changes;
}
if (!changes) {
return 0;
@@ -687,7 +680,7 @@ void CodeBlob::fwd_analyze() {
tolk_assert(ops && ops->cl == Op::_Import);
for (var_idx_t i : ops->left) {
values += i;
- if (vars[i].v_type->is_int()) {
+ if (vars[i].v_type == TypeDataInt::create()) {
values[i]->val |= VarDescr::_Int;
}
}
@@ -732,15 +725,18 @@ VarDescrList Op::fwd_analyze(VarDescrList values) {
}
case _Call: {
prepare_args(values);
- auto func = dynamic_cast<const SymValAsmFunc*>(fun_ref->value);
- if (func) {
+ if (!f_sym->is_code_function()) {
std::vector<VarDescr> res;
res.reserve(left.size());
for (var_idx_t i : left) {
res.emplace_back(i);
}
AsmOpList tmp;
- func->compile(tmp, res, args, where); // abstract interpretation of res := f (args)
+ if (f_sym->is_asm_function()) {
+ std::get<FunctionBodyAsm*>(f_sym->body)->compile(tmp); // abstract interpretation of res := f (args)
+ } else {
+ std::get<FunctionBodyBuiltin*>(f_sym->body)->compile(tmp, res, args, where);
+ }
int j = 0;
for (var_idx_t i : left) {
values.add_newval(i).set_value(res[j++]);
@@ -878,27 +874,10 @@ bool Op::set_noreturn(bool flag) {
return flag;
}
-void Op::set_impure(const CodeBlob &code) {
- // todo calling this function with `code` is a bad design (flags are assigned after Op is constructed)
- // later it's better to check this somewhere in code.emplace_back()
- if (code.flags & CodeBlob::_ForbidImpure) {
- throw ParseError(where, "an impure operation in a pure function");
- }
+void Op::set_impure_flag() {
flags |= _Impure;
}
-void Op::set_impure(const CodeBlob &code, bool flag) {
- if (flag) {
- if (code.flags & CodeBlob::_ForbidImpure) {
- throw ParseError(where, "an impure operation in a pure function");
- }
- flags |= _Impure;
- } else {
- flags &= ~_Impure;
- }
-}
-
-
bool Op::mark_noreturn() {
switch (cl) {
case _Nop:
diff --git a/tolk/asmops.cpp b/tolk/asmops.cpp
index 8db75091b..547922dad 100644
--- a/tolk/asmops.cpp
+++ b/tolk/asmops.cpp
@@ -52,10 +52,10 @@ std::ostream& operator<<(std::ostream& os, AsmOp::SReg stack_reg) {
}
}
-AsmOp AsmOp::Const(int arg, std::string push_op, td::RefInt256 origin) {
+AsmOp AsmOp::Const(int arg, const std::string& push_op) {
std::ostringstream os;
os << arg << ' ' << push_op;
- return AsmOp::Const(os.str(), origin);
+ return AsmOp::Const(os.str());
}
AsmOp AsmOp::make_stk2(int a, int b, const char* str, int delta) {
@@ -161,36 +161,36 @@ AsmOp AsmOp::UnTuple(int a) {
return AsmOp::Custom(os.str(), 1, a);
}
-AsmOp AsmOp::IntConst(td::RefInt256 x) {
+AsmOp AsmOp::IntConst(const td::RefInt256& x) {
if (x->signed_fits_bits(8)) {
- return AsmOp::Const(dec_string(x) + " PUSHINT", x);
+ return AsmOp::Const(dec_string(x) + " PUSHINT");
}
if (!x->is_valid()) {
- return AsmOp::Const("PUSHNAN", x);
+ return AsmOp::Const("PUSHNAN");
}
int k = is_pos_pow2(x);
if (k >= 0) {
- return AsmOp::Const(k, "PUSHPOW2", x);
+ return AsmOp::Const(k, "PUSHPOW2");
}
k = is_pos_pow2(x + 1);
if (k >= 0) {
- return AsmOp::Const(k, "PUSHPOW2DEC", x);
+ return AsmOp::Const(k, "PUSHPOW2DEC");
}
k = is_pos_pow2(-x);
if (k >= 0) {
- return AsmOp::Const(k, "PUSHNEGPOW2", x);
+ return AsmOp::Const(k, "PUSHNEGPOW2");
}
if (!x->mod_pow2_short(23)) {
- return AsmOp::Const(dec_string(x) + " PUSHINTX", x);
+ return AsmOp::Const(dec_string(x) + " PUSHINTX");
}
- return AsmOp::Const(dec_string(x) + " PUSHINT", x);
+ return AsmOp::Const(dec_string(x) + " PUSHINT");
}
AsmOp AsmOp::BoolConst(bool f) {
return AsmOp::Const(f ? "TRUE" : "FALSE");
}
-AsmOp AsmOp::Parse(std::string custom_op) {
+AsmOp AsmOp::Parse(const std::string& custom_op) {
if (custom_op == "NOP") {
return AsmOp::Nop();
} else if (custom_op == "SWAP") {
diff --git a/tolk/ast-from-tokens.cpp b/tolk/ast-from-tokens.cpp
index 1a1d199ec..58592011e 100644
--- a/tolk/ast-from-tokens.cpp
+++ b/tolk/ast-from-tokens.cpp
@@ -16,8 +16,8 @@
*/
#include "ast-from-tokens.h"
#include "ast.h"
+#include "type-system.h"
#include "platform-utils.h"
-#include "type-expr.h"
#include "tolk-version.h"
/*
@@ -75,7 +75,7 @@ static void fire_error_mix_and_or_no_parenthesis(SrcLocation loc, std::string_vi
// the only way to suppress this error for the programmer is to use parenthesis
// (how do we detect presence of parenthesis? simple: (0!=1) is ast_parenthesized_expr{ast_binary_operator},
// that's why if rhs->type == ast_binary_operator, it's not surrounded by parenthesis)
-static void diagnose_bitwise_precedence(SrcLocation loc, std::string_view operator_name, AnyV lhs, AnyV rhs) {
+static void diagnose_bitwise_precedence(SrcLocation loc, std::string_view operator_name, AnyExprV lhs, AnyExprV rhs) {
// handle "flags & 0xFF != 0" (rhs = "0xFF != 0")
if (rhs->type == ast_binary_operator && is_comparison_binary_op(rhs->as<ast_binary_operator>()->tok)) {
fire_error_lower_precedence(loc, operator_name, rhs->as<ast_binary_operator>()->operator_name);
@@ -90,7 +90,7 @@ static void diagnose_bitwise_precedence(SrcLocation loc, std::string_view operat
// similar to above, but detect potentially invalid usage of && and ||
// since anyway, using parenthesis when both && and || occur in the same expression,
// && and || have equal operator precedence in Tolk
-static void diagnose_and_or_precedence(SrcLocation loc, AnyV lhs, TokenType rhs_tok, std::string_view rhs_operator_name) {
+static void diagnose_and_or_precedence(SrcLocation loc, AnyExprV lhs, TokenType rhs_tok, std::string_view rhs_operator_name) {
if (auto lhs_op = lhs->try_as<ast_binary_operator>()) {
// handle "arg1 & arg2 | arg3" (lhs = "arg1 & arg2")
if (is_bitwise_binary_op(lhs_op->tok) && is_bitwise_binary_op(rhs_tok) && lhs_op->tok != rhs_tok) {
@@ -105,7 +105,7 @@ static void diagnose_and_or_precedence(SrcLocation loc, AnyV lhs, TokenType rhs_
}
// diagnose "a << 8 + 1" (equivalent to "a << 9", probably unexpected)
-static void diagnose_addition_in_bitshift(SrcLocation loc, std::string_view bitshift_operator_name, AnyV rhs) {
+static void diagnose_addition_in_bitshift(SrcLocation loc, std::string_view bitshift_operator_name, AnyExprV rhs) {
if (rhs->type == ast_binary_operator && is_add_or_sub_binary_op(rhs->as<ast_binary_operator>()->tok)) {
fire_error_lower_precedence(loc, bitshift_operator_name, rhs->as<ast_binary_operator>()->operator_name);
}
@@ -122,7 +122,7 @@ static void fire_error_FunC_style_var_declaration(Lexer& lex) {
}
// replace (a == null) and similar to isNull(a) (call of a built-in function)
-static AnyV maybe_replace_eq_null_with_isNull_call(V<ast_binary_operator> v) {
+static AnyExprV maybe_replace_eq_null_with_isNull_call(V<ast_binary_operator> v) {
bool has_null = v->get_lhs()->type == ast_null_keyword || v->get_rhs()->type == ast_null_keyword;
bool replace = has_null && (v->tok == tok_eq || v->tok == tok_neq);
if (!replace) {
@@ -130,9 +130,10 @@ static AnyV maybe_replace_eq_null_with_isNull_call(V<ast_binary_operator> v) {
}
auto v_ident = createV<ast_identifier>(v->loc, "__isNull"); // built-in function
- AnyV v_null = v->get_lhs()->type == ast_null_keyword ? v->get_rhs() : v->get_lhs();
- AnyV v_arg = createV<ast_argument>(v->loc, v_null, false);
- AnyV v_isNull = createV<ast_function_call>(v->loc, v_ident, createV<ast_argument_list>(v->loc, {v_arg}));
+ auto v_ref = createV<ast_reference>(v->loc, v_ident, nullptr);
+ AnyExprV v_null = v->get_lhs()->type == ast_null_keyword ? v->get_rhs() : v->get_lhs();
+ AnyExprV v_arg = createV<ast_argument>(v->loc, v_null, false);
+ AnyExprV v_isNull = createV<ast_function_call>(v->loc, v_ref, createV<ast_argument_list>(v->loc, {v_arg}));
if (v->tok == tok_neq) {
v_isNull = createV<ast_unary_operator>(v->loc, "!", tok_logical_not, v_isNull);
}
@@ -146,98 +147,14 @@ static AnyV maybe_replace_eq_null_with_isNull_call(V<ast_binary_operator> v) {
*
*/
-// TE ::= TA | TA -> TE
-// TA ::= int | ... | cont | var | _ | () | ( TE { , TE } ) | [ TE { , TE } ]
-static TypeExpr* parse_type(Lexer& lex, V<ast_genericsT_list> genericsT_list);
-static TypeExpr* parse_type1(Lexer& lex, V<ast_genericsT_list> genericsT_list) {
- switch (lex.tok()) {
- case tok_int:
- lex.next();
- return TypeExpr::new_atomic(TypeExpr::_Int);
- case tok_cell:
- lex.next();
- return TypeExpr::new_atomic(TypeExpr::_Cell);
- case tok_slice:
- lex.next();
- return TypeExpr::new_atomic(TypeExpr::_Slice);
- case tok_builder:
- lex.next();
- return TypeExpr::new_atomic(TypeExpr::_Builder);
- case tok_continuation:
- lex.next();
- return TypeExpr::new_atomic(TypeExpr::_Continutaion);
- case tok_tuple:
- lex.next();
- return TypeExpr::new_atomic(TypeExpr::_Tuple);
- case tok_auto:
- lex.next();
- return TypeExpr::new_hole();
- case tok_void:
- lex.next();
- return TypeExpr::new_tensor({});
- case tok_bool:
- lex.error("bool type is not supported yet");
- case tok_self:
- lex.error("`self` type can be used only as a return type of a function (enforcing it to be chainable)");
- case tok_identifier:
- if (int idx = genericsT_list ? genericsT_list->lookup_idx(lex.cur_str()) : -1; idx != -1) {
- lex.next();
- return genericsT_list->get_item(idx)->created_type;
- }
- break;
- case tok_oppar: {
- lex.next();
- if (lex.tok() == tok_clpar) {
- lex.next();
- return TypeExpr::new_unit();
- }
- std::vector<TypeExpr*> sub{1, parse_type(lex, genericsT_list)};
- while (lex.tok() == tok_comma) {
- lex.next();
- sub.push_back(parse_type(lex, genericsT_list));
- }
- lex.expect(tok_clpar, "`)`");
- return TypeExpr::new_tensor(std::move(sub));
- }
- case tok_opbracket: {
- lex.next();
- if (lex.tok() == tok_clbracket) {
- lex.next();
- return TypeExpr::new_tuple({});
- }
- std::vector<TypeExpr*> sub{1, parse_type(lex, genericsT_list)};
- while (lex.tok() == tok_comma) {
- lex.next();
- sub.push_back(parse_type(lex, genericsT_list));
- }
- lex.expect(tok_clbracket, "`]`");
- return TypeExpr::new_tuple(std::move(sub));
- }
- default:
- break;
- }
- lex.unexpected("<type>");
-}
+AnyExprV parse_expr(Lexer& lex);
-static TypeExpr* parse_type(Lexer& lex, V<ast_genericsT_list> genericsT_list) {
- TypeExpr* res = parse_type1(lex, genericsT_list);
- if (lex.tok() == tok_arrow) {
- lex.next();
- TypeExpr* to = parse_type(lex, genericsT_list);
- return TypeExpr::new_map(res, to);
- }
- return res;
-}
-
-AnyV parse_expr(Lexer& lex);
-
-static AnyV parse_parameter(Lexer& lex, V<ast_genericsT_list> genericsT_list, bool is_first) {
+static AnyV parse_parameter(Lexer& lex, bool is_first) {
SrcLocation loc = lex.cur_location();
// optional keyword `mutate` meaning that a function will mutate a passed argument (like passed by reference)
bool declared_as_mutate = false;
- bool is_param_self = false;
if (lex.tok() == tok_mutate) {
lex.next();
declared_as_mutate = true;
@@ -252,24 +169,16 @@ static AnyV parse_parameter(Lexer& lex, V<ast_genericsT_list> genericsT_list, bo
lex.error("`self` can only be the first parameter");
}
param_name = "self";
- is_param_self = true;
} else if (lex.tok() != tok_underscore) {
lex.unexpected("parameter name");
}
- auto v_ident = createV<ast_identifier>(lex.cur_location(), param_name);
lex.next();
- // parameter type after colon, also mandatory (even explicit ":auto")
+ // parameter type after colon are mandatory
lex.expect(tok_colon, "`: <parameter_type>`");
- TypeExpr* param_type = parse_type(lex, genericsT_list);
- if (declared_as_mutate && !param_type->has_fixed_width()) {
- throw ParseError(loc, "`mutate` parameter must be strictly typed");
- }
- if (is_param_self && !param_type->has_fixed_width()) {
- throw ParseError(loc, "`self` parameter must be strictly typed");
- }
+ TypePtr param_type = parse_type_from_tokens(lex);
- return createV<ast_parameter>(loc, v_ident, param_type, declared_as_mutate);
+ return createV<ast_parameter>(loc, param_name, param_type, declared_as_mutate);
}
static AnyV parse_global_var_declaration(Lexer& lex, const std::vector<V<ast_annotation>>& annotations) {
@@ -282,7 +191,7 @@ static AnyV parse_global_var_declaration(Lexer& lex, const std::vector<V<ast_ann
auto v_ident = createV<ast_identifier>(lex.cur_location(), lex.cur_str());
lex.next();
lex.expect(tok_colon, "`:`");
- TypeExpr* declared_type = parse_type(lex, nullptr);
+ TypePtr declared_type = parse_type_from_tokens(lex);
if (lex.tok() == tok_comma) {
lex.error("multiple declarations are not allowed, split globals on separate lines");
}
@@ -302,21 +211,13 @@ static AnyV parse_constant_declaration(Lexer& lex, const std::vector<V<ast_annot
lex.check(tok_identifier, "constant name");
auto v_ident = createV<ast_identifier>(lex.cur_location(), lex.cur_str());
lex.next();
- TypeExpr *declared_type = nullptr;
+ TypePtr declared_type = nullptr;
if (lex.tok() == tok_colon) {
lex.next();
- if (lex.tok() == tok_int) {
- declared_type = TypeExpr::new_atomic(TypeExpr::_Int);
- lex.next();
- } else if (lex.tok() == tok_slice) {
- declared_type = TypeExpr::new_atomic(TypeExpr::_Slice);
- lex.next();
- } else {
- lex.error("a constant can be int or slice only");
- }
+ declared_type = parse_type_from_tokens(lex);
}
lex.expect(tok_assign, "`=`");
- AnyV init_value = parse_expr(lex);
+ AnyExprV init_value = parse_expr(lex);
if (lex.tok() == tok_comma) {
lex.error("multiple declarations are not allowed, split constants on separate lines");
}
@@ -325,15 +226,15 @@ static AnyV parse_constant_declaration(Lexer& lex, const std::vector<V<ast_annot
}
// "parameters" are at function declaration: `fun f(param1: int, mutate param2: slice)`
-static V<ast_parameter_list> parse_parameter_list(Lexer& lex, V<ast_genericsT_list> genericsT_list) {
+static V<ast_parameter_list> parse_parameter_list(Lexer& lex) {
SrcLocation loc = lex.cur_location();
std::vector<AnyV> params;
lex.expect(tok_oppar, "parameter list");
if (lex.tok() != tok_clpar) {
- params.push_back(parse_parameter(lex, genericsT_list, true));
+ params.push_back(parse_parameter(lex, true));
while (lex.tok() == tok_comma) {
lex.next();
- params.push_back(parse_parameter(lex, genericsT_list, false));
+ params.push_back(parse_parameter(lex, false));
}
}
lex.expect(tok_clpar, "`)`");
@@ -341,7 +242,7 @@ static V<ast_parameter_list> parse_parameter_list(Lexer& lex, V<ast_genericsT_li
}
// "arguments" are at function call: `f(arg1, mutate arg2)`
-static AnyV parse_argument(Lexer& lex) {
+static AnyExprV parse_argument(Lexer& lex) {
SrcLocation loc = lex.cur_location();
// keyword `mutate` is necessary when a parameter is declared `mutate` (to make mutation obvious for the reader)
@@ -351,13 +252,13 @@ static AnyV parse_argument(Lexer& lex) {
passed_as_mutate = true;
}
- AnyV expr = parse_expr(lex);
+ AnyExprV expr = parse_expr(lex);
return createV<ast_argument>(loc, expr, passed_as_mutate);
}
static V<ast_argument_list> parse_argument_list(Lexer& lex) {
SrcLocation loc = lex.cur_location();
- std::vector<AnyV> args;
+ std::vector<AnyExprV> args;
lex.expect(tok_oppar, "`(`");
if (lex.tok() != tok_clpar) {
args.push_back(parse_argument(lex));
@@ -370,8 +271,28 @@ static V<ast_argument_list> parse_argument_list(Lexer& lex) {
return createV<ast_argument_list>(loc, std::move(args));
}
+static V<ast_instantiationT_list> parse_maybe_instantiationTs_after_identifier(Lexer& lex) {
+ lex.check(tok_lt, "`<`");
+ Lexer::SavedPositionForLookahead backup = lex.save_parsing_position();
+ try {
+ SrcLocation loc = lex.cur_location();
+ lex.next();
+ std::vector<AnyV> instantiationTs;
+ instantiationTs.push_back(createV<ast_instantiationT_item>(lex.cur_location(), parse_type_from_tokens(lex)));
+ while (lex.tok() == tok_comma) {
+ lex.next();
+ instantiationTs.push_back(createV<ast_instantiationT_item>(lex.cur_location(), parse_type_from_tokens(lex)));
+ }
+ lex.expect(tok_gt, "`>`");
+ return createV<ast_instantiationT_list>(loc, std::move(instantiationTs));
+ } catch (const ParseError&) {
+ lex.restore_position(backup);
+ return nullptr;
+ }
+}
+
// parse (expr) / [expr] / identifier / number
-static AnyV parse_expr100(Lexer& lex) {
+static AnyExprV parse_expr100(Lexer& lex) {
SrcLocation loc = lex.cur_location();
switch (lex.tok()) {
case tok_oppar: {
@@ -380,12 +301,12 @@ static AnyV parse_expr100(Lexer& lex) {
lex.next();
return createV<ast_tensor>(loc, {});
}
- AnyV first = parse_expr(lex);
+ AnyExprV first = parse_expr(lex);
if (lex.tok() == tok_clpar) {
lex.next();
- return createV<ast_parenthesized_expr>(loc, first);
+ return createV<ast_parenthesized_expression>(loc, first);
}
- std::vector<AnyV> items(1, first);
+ std::vector<AnyExprV> items(1, first);
while (lex.tok() == tok_comma) {
lex.next();
items.emplace_back(parse_expr(lex));
@@ -397,20 +318,24 @@ static AnyV parse_expr100(Lexer& lex) {
lex.next();
if (lex.tok() == tok_clbracket) {
lex.next();
- return createV<ast_tensor_square>(loc, {});
+ return createV<ast_typed_tuple>(loc, {});
}
- std::vector<AnyV> items(1, parse_expr(lex));
+ std::vector<AnyExprV> items(1, parse_expr(lex));
while (lex.tok() == tok_comma) {
lex.next();
items.emplace_back(parse_expr(lex));
}
lex.expect(tok_clbracket, "`]`");
- return createV<ast_tensor_square>(loc, std::move(items));
+ return createV<ast_typed_tuple>(loc, std::move(items));
}
case tok_int_const: {
- std::string_view int_val = lex.cur_str();
+ std::string_view orig_str = lex.cur_str();
+ td::RefInt256 intval = td::string_to_int256(static_cast<std::string>(orig_str));
+ if (intval.is_null() || !intval->signed_fits_bits(257)) {
+ lex.error("invalid integer constant");
+ }
lex.next();
- return createV<ast_int_const>(loc, int_val);
+ return createV<ast_int_const>(loc, std::move(intval), orig_str);
}
case tok_string_const: {
std::string_view str_val = lex.cur_str();
@@ -440,12 +365,17 @@ static AnyV parse_expr100(Lexer& lex) {
}
case tok_self: {
lex.next();
- return createV<ast_self_keyword>(loc);
+ auto v_ident = createV<ast_identifier>(loc, "self");
+ return createV<ast_reference>(loc, v_ident, nullptr);
}
case tok_identifier: {
- std::string_view str_val = lex.cur_str();
+ auto v_ident = createV<ast_identifier>(loc, lex.cur_str());
+ V<ast_instantiationT_list> v_instantiationTs = nullptr;
lex.next();
- return createV<ast_identifier>(loc, str_val);
+ if (lex.tok() == tok_lt) {
+ v_instantiationTs = parse_maybe_instantiationTs_after_identifier(lex);
+ }
+ return createV<ast_reference>(loc, v_ident, v_instantiationTs);
}
default: {
// show a proper error for `int i` (FunC-style declarations)
@@ -458,51 +388,74 @@ static AnyV parse_expr100(Lexer& lex) {
}
}
-// parse E(args)
-static AnyV parse_expr90(Lexer& lex) {
- AnyV res = parse_expr100(lex);
- if (lex.tok() == tok_oppar) {
- return createV<ast_function_call>(res->loc, res, parse_argument_list(lex));
+// parse E(...) (left-to-right)
+static AnyExprV parse_expr90(Lexer& lex) {
+ AnyExprV res = parse_expr100(lex);
+ while (lex.tok() == tok_oppar) {
+ res = createV<ast_function_call>(res->loc, res, parse_argument_list(lex));
}
return res;
}
-// parse E.method(...) (left-to-right)
-static AnyV parse_expr80(Lexer& lex) {
- AnyV lhs = parse_expr90(lex);
+// parse E.field and E.method(...) (left-to-right)
+static AnyExprV parse_expr80(Lexer& lex) {
+ AnyExprV lhs = parse_expr90(lex);
while (lex.tok() == tok_dot) {
SrcLocation loc = lex.cur_location();
lex.next();
- lex.check(tok_identifier, "method name");
- std::string_view method_name = lex.cur_str();
- lex.next();
- lhs = createV<ast_dot_method_call>(loc, method_name, lhs, parse_argument_list(lex));
+ V<ast_identifier> v_ident = nullptr;
+ V<ast_instantiationT_list> v_instantiationTs = nullptr;
+ if (lex.tok() == tok_identifier) {
+ v_ident = createV<ast_identifier>(lex.cur_location(), lex.cur_str());
+ lex.next();
+ if (lex.tok() == tok_lt) {
+ v_instantiationTs = parse_maybe_instantiationTs_after_identifier(lex);
+ }
+ } else {
+ lex.unexpected("method name");
+ }
+ lhs = createV<ast_dot_access>(loc, lhs, v_ident, v_instantiationTs);
+ while (lex.tok() == tok_oppar) {
+ lhs = createV<ast_function_call>(lex.cur_location(), lhs, parse_argument_list(lex));
+ }
}
return lhs;
}
// parse ! ~ - + E (unary)
-static AnyV parse_expr75(Lexer& lex) {
+static AnyExprV parse_expr75(Lexer& lex) {
TokenType t = lex.tok();
if (t == tok_logical_not || t == tok_bitwise_not || t == tok_minus || t == tok_plus) {
SrcLocation loc = lex.cur_location();
std::string_view operator_name = lex.cur_str();
lex.next();
- AnyV rhs = parse_expr75(lex);
+ AnyExprV rhs = parse_expr75(lex);
return createV<ast_unary_operator>(loc, operator_name, t, rhs);
}
return parse_expr80(lex);
}
+// parse E as <type>
+static AnyExprV parse_expr40(Lexer& lex) {
+ AnyExprV lhs = parse_expr75(lex);
+ if (lex.tok() == tok_as) {
+ SrcLocation loc = lex.cur_location();
+ lex.next();
+ TypePtr cast_to_type = parse_type_from_tokens(lex);
+ lhs = createV<ast_cast_as_operator>(loc, lhs, cast_to_type);
+ }
+ return lhs;
+}
+
// parse E * / % ^/ ~/ E (left-to-right)
-static AnyV parse_expr30(Lexer& lex) {
- AnyV lhs = parse_expr75(lex);
+static AnyExprV parse_expr30(Lexer& lex) {
+ AnyExprV lhs = parse_expr40(lex);
TokenType t = lex.tok();
while (t == tok_mul || t == tok_div || t == tok_mod || t == tok_divC || t == tok_divR) {
SrcLocation loc = lex.cur_location();
std::string_view operator_name = lex.cur_str();
lex.next();
- AnyV rhs = parse_expr75(lex);
+ AnyExprV rhs = parse_expr40(lex);
lhs = createV<ast_binary_operator>(loc, operator_name, t, lhs, rhs);
t = lex.tok();
}
@@ -510,14 +463,14 @@ static AnyV parse_expr30(Lexer& lex) {
}
// parse E + - E (left-to-right)
-static AnyV parse_expr20(Lexer& lex) {
- AnyV lhs = parse_expr30(lex);
+static AnyExprV parse_expr20(Lexer& lex) {
+ AnyExprV lhs = parse_expr30(lex);
TokenType t = lex.tok();
while (t == tok_minus || t == tok_plus) {
SrcLocation loc = lex.cur_location();
std::string_view operator_name = lex.cur_str();
lex.next();
- AnyV rhs = parse_expr30(lex);
+ AnyExprV rhs = parse_expr30(lex);
lhs = createV<ast_binary_operator>(loc, operator_name, t, lhs, rhs);
t = lex.tok();
}
@@ -525,14 +478,14 @@ static AnyV parse_expr20(Lexer& lex) {
}
// parse E << >> ~>> ^>> E (left-to-right)
-static AnyV parse_expr17(Lexer& lex) {
- AnyV lhs = parse_expr20(lex);
+static AnyExprV parse_expr17(Lexer& lex) {
+ AnyExprV lhs = parse_expr20(lex);
TokenType t = lex.tok();
while (t == tok_lshift || t == tok_rshift || t == tok_rshiftC || t == tok_rshiftR) {
SrcLocation loc = lex.cur_location();
std::string_view operator_name = lex.cur_str();
lex.next();
- AnyV rhs = parse_expr20(lex);
+ AnyExprV rhs = parse_expr20(lex);
diagnose_addition_in_bitshift(loc, operator_name, rhs);
lhs = createV<ast_binary_operator>(loc, operator_name, t, lhs, rhs);
t = lex.tok();
@@ -541,14 +494,14 @@ static AnyV parse_expr17(Lexer& lex) {
}
// parse E == < > <= >= != <=> E (left-to-right)
-static AnyV parse_expr15(Lexer& lex) {
- AnyV lhs = parse_expr17(lex);
+static AnyExprV parse_expr15(Lexer& lex) {
+ AnyExprV lhs = parse_expr17(lex);
TokenType t = lex.tok();
if (t == tok_eq || t == tok_lt || t == tok_gt || t == tok_leq || t == tok_geq || t == tok_neq || t == tok_spaceship) {
SrcLocation loc = lex.cur_location();
std::string_view operator_name = lex.cur_str();
lex.next();
- AnyV rhs = parse_expr17(lex);
+ AnyExprV rhs = parse_expr17(lex);
lhs = createV<ast_binary_operator>(loc, operator_name, t, lhs, rhs);
if (t == tok_eq || t == tok_neq) {
lhs = maybe_replace_eq_null_with_isNull_call(lhs->as<ast_binary_operator>());
@@ -558,14 +511,14 @@ static AnyV parse_expr15(Lexer& lex) {
}
// parse E & | ^ E (left-to-right)
-static AnyV parse_expr14(Lexer& lex) {
- AnyV lhs = parse_expr15(lex);
+static AnyExprV parse_expr14(Lexer& lex) {
+ AnyExprV lhs = parse_expr15(lex);
TokenType t = lex.tok();
while (t == tok_bitwise_and || t == tok_bitwise_or || t == tok_bitwise_xor) {
SrcLocation loc = lex.cur_location();
std::string_view operator_name = lex.cur_str();
lex.next();
- AnyV rhs = parse_expr15(lex);
+ AnyExprV rhs = parse_expr15(lex);
diagnose_bitwise_precedence(loc, operator_name, lhs, rhs);
diagnose_and_or_precedence(loc, lhs, t, operator_name);
lhs = createV<ast_binary_operator>(loc, operator_name, t, lhs, rhs);
@@ -575,14 +528,14 @@ static AnyV parse_expr14(Lexer& lex) {
}
// parse E && || E (left-to-right)
-static AnyV parse_expr13(Lexer& lex) {
- AnyV lhs = parse_expr14(lex);
+static AnyExprV parse_expr13(Lexer& lex) {
+ AnyExprV lhs = parse_expr14(lex);
TokenType t = lex.tok();
while (t == tok_logical_and || t == tok_logical_or) {
SrcLocation loc = lex.cur_location();
std::string_view operator_name = lex.cur_str();
lex.next();
- AnyV rhs = parse_expr14(lex);
+ AnyExprV rhs = parse_expr14(lex);
diagnose_and_or_precedence(loc, lhs, t, operator_name);
lhs = createV<ast_binary_operator>(loc, operator_name, t, lhs, rhs);
t = lex.tok();
@@ -591,46 +544,51 @@ static AnyV parse_expr13(Lexer& lex) {
}
// parse E = += -= E and E ? E : E (right-to-left)
-static AnyV parse_expr10(Lexer& lex) {
- AnyV lhs = parse_expr13(lex);
+static AnyExprV parse_expr10(Lexer& lex) {
+ AnyExprV lhs = parse_expr13(lex);
TokenType t = lex.tok();
+ if (t == tok_assign) {
+ SrcLocation loc = lex.cur_location();
+ lex.next();
+ AnyExprV rhs = parse_expr10(lex);
+ return createV<ast_assign>(loc, lhs, rhs);
+ }
if (t == tok_set_plus || t == tok_set_minus || t == tok_set_mul || t == tok_set_div ||
t == tok_set_mod || t == tok_set_lshift || t == tok_set_rshift ||
- t == tok_set_bitwise_and || t == tok_set_bitwise_or || t == tok_set_bitwise_xor ||
- t == tok_assign) {
+ t == tok_set_bitwise_and || t == tok_set_bitwise_or || t == tok_set_bitwise_xor) {
SrcLocation loc = lex.cur_location();
- std::string_view operator_name = lex.cur_str();
+ std::string_view operator_name = lex.cur_str().substr(0, lex.cur_str().size() - 1); // "+" for +=
lex.next();
- AnyV rhs = parse_expr10(lex);
- return createV<ast_binary_operator>(loc, operator_name, t, lhs, rhs);
+ AnyExprV rhs = parse_expr10(lex);
+ return createV<ast_set_assign>(loc, operator_name, t, lhs, rhs);
}
if (t == tok_question) {
SrcLocation loc = lex.cur_location();
lex.next();
- AnyV when_true = parse_expr10(lex);
+ AnyExprV when_true = parse_expr10(lex);
lex.expect(tok_colon, "`:`");
- AnyV when_false = parse_expr10(lex);
+ AnyExprV when_false = parse_expr10(lex);
return createV<ast_ternary_operator>(loc, lhs, when_true, when_false);
}
return lhs;
}
-AnyV parse_expr(Lexer& lex) {
+AnyExprV parse_expr(Lexer& lex) {
return parse_expr10(lex);
}
AnyV parse_statement(Lexer& lex);
-static AnyV parse_var_declaration_lhs(Lexer& lex, bool is_immutable) {
+static AnyExprV parse_var_declaration_lhs(Lexer& lex, bool is_immutable) {
SrcLocation loc = lex.cur_location();
if (lex.tok() == tok_oppar) {
lex.next();
- AnyV first = parse_var_declaration_lhs(lex, is_immutable);
+ AnyExprV first = parse_var_declaration_lhs(lex, is_immutable);
if (lex.tok() == tok_clpar) {
lex.next();
- return createV<ast_parenthesized_expr>(loc, first);
+ return first;
}
- std::vector<AnyV> args(1, first);
+ std::vector<AnyExprV> args(1, first);
while (lex.tok() == tok_comma) {
lex.next();
args.push_back(parse_var_declaration_lhs(lex, is_immutable));
@@ -640,57 +598,57 @@ static AnyV parse_var_declaration_lhs(Lexer& lex, bool is_immutable) {
}
if (lex.tok() == tok_opbracket) {
lex.next();
- std::vector<AnyV> args(1, parse_var_declaration_lhs(lex, is_immutable));
+ std::vector<AnyExprV> args(1, parse_var_declaration_lhs(lex, is_immutable));
while (lex.tok() == tok_comma) {
lex.next();
args.push_back(parse_var_declaration_lhs(lex, is_immutable));
}
lex.expect(tok_clbracket, "`]`");
- return createV<ast_tensor_square>(loc, std::move(args));
+ return createV<ast_typed_tuple>(loc, std::move(args));
}
if (lex.tok() == tok_identifier) {
auto v_ident = createV<ast_identifier>(loc, lex.cur_str());
- TypeExpr* declared_type = nullptr;
+ TypePtr declared_type = nullptr;
bool marked_as_redef = false;
lex.next();
if (lex.tok() == tok_colon) {
lex.next();
- declared_type = parse_type(lex, nullptr);
+ declared_type = parse_type_from_tokens(lex);
} else if (lex.tok() == tok_redef) {
lex.next();
marked_as_redef = true;
}
- return createV<ast_local_var>(loc, v_ident, declared_type, is_immutable, marked_as_redef);
+ return createV<ast_local_var_lhs>(loc, v_ident, declared_type, is_immutable, marked_as_redef);
}
if (lex.tok() == tok_underscore) {
- TypeExpr* declared_type = nullptr;
+ TypePtr declared_type = nullptr;
lex.next();
if (lex.tok() == tok_colon) {
lex.next();
- declared_type = parse_type(lex, nullptr);
+ declared_type = parse_type_from_tokens(lex);
}
- return createV<ast_local_var>(loc, createV<ast_underscore>(loc), declared_type, true, false);
+ return createV<ast_local_var_lhs>(loc, createV<ast_identifier>(loc, ""), declared_type, true, false);
}
lex.unexpected("variable name");
}
-static AnyV parse_local_vars_declaration(Lexer& lex) {
+static AnyV parse_local_vars_declaration_assignment(Lexer& lex) {
SrcLocation loc = lex.cur_location();
bool is_immutable = lex.tok() == tok_val;
lex.next();
- AnyV lhs = parse_var_declaration_lhs(lex, is_immutable);
+ AnyExprV lhs = createV<ast_local_vars_declaration>(loc, parse_var_declaration_lhs(lex, is_immutable));
if (lex.tok() != tok_assign) {
lex.error("variables declaration must be followed by assignment: `var xxx = ...`");
}
lex.next();
- AnyV assigned_val = parse_expr(lex);
+ AnyExprV rhs = parse_expr(lex);
if (lex.tok() == tok_comma) {
lex.error("multiple declarations are not allowed, split variables on separate lines");
}
lex.expect(tok_semicolon, "`;`");
- return createV<ast_local_vars_declaration>(loc, lhs, assigned_val);
+ return createV<ast_assign>(loc, lhs, rhs);
}
static V<ast_sequence> parse_sequence(Lexer& lex) {
@@ -708,32 +666,27 @@ static V<ast_sequence> parse_sequence(Lexer& lex) {
static AnyV parse_return_statement(Lexer& lex) {
SrcLocation loc = lex.cur_location();
lex.expect(tok_return, "`return`");
- AnyV child = lex.tok() == tok_semicolon // `return;` actually means `return ();` (which is void)
- ? createV<ast_tensor>(lex.cur_location(), {})
+ AnyExprV child = lex.tok() == tok_semicolon // `return;` actually means "nothing" (inferred as void)
+ ? createV<ast_empty_expression>(lex.cur_location())
: parse_expr(lex);
lex.expect(tok_semicolon, "`;`");
return createV<ast_return_statement>(loc, child);
}
-static AnyV parse_if_statement(Lexer& lex, bool is_ifnot) {
+static AnyV parse_if_statement(Lexer& lex) {
SrcLocation loc = lex.cur_location();
lex.expect(tok_if, "`if`");
lex.expect(tok_oppar, "`(`");
- AnyV cond = parse_expr(lex);
+ AnyExprV cond = parse_expr(lex);
lex.expect(tok_clpar, "`)`");
- // replace if(!expr) with ifnot(expr) (this should be done later, but for now, let this be right at parsing time)
- if (auto v_not = cond->try_as<ast_unary_operator>(); v_not && v_not->tok == tok_logical_not) {
- is_ifnot = !is_ifnot;
- cond = v_not->get_rhs();
- }
V<ast_sequence> if_body = parse_sequence(lex);
V<ast_sequence> else_body = nullptr;
if (lex.tok() == tok_else) { // else if(e) { } or else { }
lex.next();
if (lex.tok() == tok_if) {
- AnyV v_inner_if = parse_if_statement(lex, false);
+ AnyV v_inner_if = parse_if_statement(lex);
else_body = createV<ast_sequence>(v_inner_if->loc, lex.cur_location(), {v_inner_if});
} else {
else_body = parse_sequence(lex);
@@ -741,14 +694,14 @@ static AnyV parse_if_statement(Lexer& lex, bool is_ifnot) {
} else { // no 'else', create empty block
else_body = createV<ast_sequence>(lex.cur_location(), lex.cur_location(), {});
}
- return createV<ast_if_statement>(loc, is_ifnot, cond, if_body, else_body);
+ return createV<ast_if_statement>(loc, false, cond, if_body, else_body);
}
static AnyV parse_repeat_statement(Lexer& lex) {
SrcLocation loc = lex.cur_location();
lex.expect(tok_repeat, "`repeat`");
lex.expect(tok_oppar, "`(`");
- AnyV cond = parse_expr(lex);
+ AnyExprV cond = parse_expr(lex);
lex.expect(tok_clpar, "`)`");
V<ast_sequence> body = parse_sequence(lex);
return createV<ast_repeat_statement>(loc, cond, body);
@@ -758,7 +711,7 @@ static AnyV parse_while_statement(Lexer& lex) {
SrcLocation loc = lex.cur_location();
lex.expect(tok_while, "`while`");
lex.expect(tok_oppar, "`(`");
- AnyV cond = parse_expr(lex);
+ AnyExprV cond = parse_expr(lex);
lex.expect(tok_clpar, "`)`");
V<ast_sequence> body = parse_sequence(lex);
return createV<ast_while_statement>(loc, cond, body);
@@ -770,31 +723,38 @@ static AnyV parse_do_while_statement(Lexer& lex) {
V<ast_sequence> body = parse_sequence(lex);
lex.expect(tok_while, "`while`");
lex.expect(tok_oppar, "`(`");
- AnyV cond = parse_expr(lex);
+ AnyExprV cond = parse_expr(lex);
lex.expect(tok_clpar, "`)`");
lex.expect(tok_semicolon, "`;`");
return createV<ast_do_while_statement>(loc, body, cond);
}
-static AnyV parse_catch_variable(Lexer& lex) {
+static AnyExprV parse_catch_variable(Lexer& lex) {
SrcLocation loc = lex.cur_location();
if (lex.tok() == tok_identifier) {
std::string_view var_name = lex.cur_str();
lex.next();
- return createV<ast_identifier>(loc, var_name);
+ auto v_ident = createV<ast_identifier>(loc, var_name);
+ return createV<ast_reference>(loc, v_ident, nullptr);
}
if (lex.tok() == tok_underscore) {
lex.next();
- return createV<ast_underscore>(loc);
+ auto v_ident = createV<ast_identifier>(loc, "");
+ return createV<ast_reference>(loc, v_ident, nullptr);
}
lex.unexpected("identifier");
}
+static AnyExprV create_catch_underscore_variable(const Lexer& lex) {
+ auto v_ident = createV<ast_identifier>(lex.cur_location(), "");
+ return createV<ast_reference>(lex.cur_location(), v_ident, nullptr);
+}
+
static AnyV parse_throw_statement(Lexer& lex) {
SrcLocation loc = lex.cur_location();
lex.expect(tok_throw, "`throw`");
- AnyV thrown_code, thrown_arg;
+ AnyExprV thrown_code, thrown_arg;
if (lex.tok() == tok_oppar) { // throw (code) or throw (code, arg)
lex.next();
thrown_code = parse_expr(lex);
@@ -802,12 +762,12 @@ static AnyV parse_throw_statement(Lexer& lex) {
lex.next();
thrown_arg = parse_expr(lex);
} else {
- thrown_arg = createV<ast_empty>(loc);
+ thrown_arg = createV<ast_empty_expression>(loc);
}
lex.expect(tok_clpar, "`)`");
} else { // throw code
thrown_code = parse_expr(lex);
- thrown_arg = createV<ast_empty>(loc);
+ thrown_arg = createV<ast_empty_expression>(loc);
}
lex.expect(tok_semicolon, "`;`");
@@ -819,8 +779,8 @@ static AnyV parse_assert_statement(Lexer& lex) {
lex.expect(tok_assert, "`assert`");
lex.expect(tok_oppar, "`(`");
- AnyV cond = parse_expr(lex);
- AnyV thrown_code;
+ AnyExprV cond = parse_expr(lex);
+ AnyExprV thrown_code;
if (lex.tok() == tok_comma) { // assert(cond, code)
lex.next();
thrown_code = parse_expr(lex);
@@ -840,7 +800,7 @@ static AnyV parse_try_catch_statement(Lexer& lex) {
lex.expect(tok_try, "`try`");
V<ast_sequence> try_body = parse_sequence(lex);
- std::vector<AnyV> catch_args;
+ std::vector<AnyExprV> catch_args;
lex.expect(tok_catch, "`catch`");
SrcLocation catch_loc = lex.cur_location();
if (lex.tok() == tok_oppar) {
@@ -850,12 +810,12 @@ static AnyV parse_try_catch_statement(Lexer& lex) {
lex.next();
catch_args.push_back(parse_catch_variable(lex));
} else { // catch (excNo) -> catch (excNo, _)
- catch_args.push_back(createV<ast_underscore>(catch_loc));
+ catch_args.push_back(create_catch_underscore_variable(lex));
}
lex.expect(tok_clpar, "`)`");
} else { // catch -> catch (_, _)
- catch_args.push_back(createV<ast_underscore>(catch_loc));
- catch_args.push_back(createV<ast_underscore>(catch_loc));
+ catch_args.push_back(create_catch_underscore_variable(lex));
+ catch_args.push_back(create_catch_underscore_variable(lex));
}
V<ast_tensor> catch_expr = createV<ast_tensor>(catch_loc, std::move(catch_args));
@@ -865,15 +825,15 @@ static AnyV parse_try_catch_statement(Lexer& lex) {
AnyV parse_statement(Lexer& lex) {
switch (lex.tok()) {
- case tok_var:
- case tok_val:
- return parse_local_vars_declaration(lex);
+ case tok_var: // `var x = 0` is technically an expression, but can not appear in "any place",
+ case tok_val: // only as a separate declaration
+ return parse_local_vars_declaration_assignment(lex);
case tok_opbrace:
return parse_sequence(lex);
case tok_return:
return parse_return_statement(lex);
case tok_if:
- return parse_if_statement(lex, false);
+ return parse_if_statement(lex);
case tok_repeat:
return parse_repeat_statement(lex);
case tok_do:
@@ -889,13 +849,13 @@ AnyV parse_statement(Lexer& lex) {
case tok_semicolon: {
SrcLocation loc = lex.cur_location();
lex.next();
- return createV<ast_empty>(loc);
+ return createV<ast_empty_statement>(loc);
}
case tok_break:
case tok_continue:
lex.error("break/continue from loops are not supported yet");
default: {
- AnyV expr = parse_expr(lex);
+ AnyExprV expr = parse_expr(lex);
lex.expect(tok_semicolon, "`;`");
return expr;
}
@@ -949,12 +909,10 @@ static AnyV parse_genericsT_list(Lexer& lex) {
SrcLocation loc = lex.cur_location();
std::vector<AnyV> genericsT_items;
lex.expect(tok_lt, "`<`");
- int idx = 0;
while (true) {
lex.check(tok_identifier, "T");
std::string_view nameT = lex.cur_str();
- TypeExpr* type = TypeExpr::new_var(idx++);
- genericsT_items.emplace_back(createV<ast_genericsT_item>(lex.cur_location(), type, nameT));
+ genericsT_items.emplace_back(createV<ast_genericsT_item>(lex.cur_location(), nameT));
lex.next();
if (lex.tok() != tok_comma) {
break;
@@ -976,7 +934,7 @@ static V<ast_annotation> parse_annotation(Lexer& lex) {
if (lex.tok() == tok_oppar) {
SrcLocation loc_args = lex.cur_location();
lex.next();
- std::vector<AnyV> args;
+ std::vector<AnyExprV> args;
args.push_back(parse_expr(lex));
while (lex.tok() == tok_comma) {
lex.next();
@@ -1037,11 +995,11 @@ static AnyV parse_function_declaration(Lexer& lex, const std::vector<V<ast_annot
genericsT_list = parse_genericsT_list(lex)->as<ast_genericsT_list>();
}
- V<ast_parameter_list> v_param_list = parse_parameter_list(lex, genericsT_list)->as<ast_parameter_list>();
- bool accepts_self = !v_param_list->empty() && v_param_list->get_param(0)->get_identifier()->name == "self";
+ V<ast_parameter_list> v_param_list = parse_parameter_list(lex)->as<ast_parameter_list>();
+ bool accepts_self = !v_param_list->empty() && v_param_list->get_param(0)->param_name == "self";
int n_mutate_params = v_param_list->get_mutate_params_count();
- TypeExpr* ret_type = nullptr;
+ TypePtr ret_type = nullptr;
bool returns_self = false;
if (lex.tok() == tok_colon) { // : <ret_type> (if absent, it means "auto infer", not void)
lex.next();
@@ -1051,9 +1009,9 @@ static AnyV parse_function_declaration(Lexer& lex, const std::vector<V<ast_annot
}
lex.next();
returns_self = true;
- ret_type = TypeExpr::new_unit();
+ ret_type = TypeDataVoid::create();
} else {
- ret_type = parse_type(lex, genericsT_list);
+ ret_type = parse_type_from_tokens(lex);
}
}
@@ -1064,22 +1022,10 @@ static AnyV parse_function_declaration(Lexer& lex, const std::vector<V<ast_annot
throw ParseError(loc, "get methods can't have `mutate` and `self` params");
}
- if (n_mutate_params) {
- std::vector<TypeExpr*> ret_tensor_items;
- ret_tensor_items.reserve(1 + n_mutate_params);
- for (AnyV v_param : v_param_list->get_params()) {
- if (v_param->as<ast_parameter>()->declared_as_mutate) {
- ret_tensor_items.emplace_back(v_param->as<ast_parameter>()->param_type);
- }
- }
- ret_tensor_items.emplace_back(ret_type ? ret_type : TypeExpr::new_hole());
- ret_type = TypeExpr::new_tensor(std::move(ret_tensor_items));
- }
-
AnyV v_body = nullptr;
if (lex.tok() == tok_builtin) {
- v_body = createV<ast_empty>(lex.cur_location());
+ v_body = createV<ast_empty_statement>(lex.cur_location());
lex.next();
lex.expect(tok_semicolon, "`;`");
} else if (lex.tok() == tok_opbrace) {
@@ -1093,32 +1039,43 @@ static AnyV parse_function_declaration(Lexer& lex, const std::vector<V<ast_annot
lex.unexpected("{ function body }");
}
- auto f_declaration = createV<ast_function_declaration>(loc, v_ident, v_param_list, v_body);
- f_declaration->ret_type = ret_type ? ret_type : TypeExpr::new_hole();
- f_declaration->is_entrypoint = is_entrypoint;
- f_declaration->genericsT_list = genericsT_list;
- f_declaration->marked_as_get_method = is_get_method;
- f_declaration->marked_as_builtin = v_body->type == ast_empty;
- f_declaration->accepts_self = accepts_self;
- f_declaration->returns_self = returns_self;
+ int flags = 0;
+ if (is_entrypoint) {
+ flags |= FunctionData::flagIsEntrypoint;
+ }
+ if (is_get_method) {
+ flags |= FunctionData::flagGetMethod;
+ }
+ if (accepts_self) {
+ flags |= FunctionData::flagAcceptsSelf;
+ }
+ if (returns_self) {
+ flags |= FunctionData::flagReturnsSelf;
+ }
+ td::RefInt256 method_id;
for (auto v_annotation : annotations) {
switch (v_annotation->kind) {
case AnnotationKind::inline_simple:
- f_declaration->marked_as_inline = true;
+ flags |= FunctionData::flagInline;
break;
case AnnotationKind::inline_ref:
- f_declaration->marked_as_inline_ref = true;
+ flags |= FunctionData::flagInlineRef;
break;
case AnnotationKind::pure:
- f_declaration->marked_as_pure = true;
+ flags |= FunctionData::flagMarkedAsPure;
break;
- case AnnotationKind::method_id:
+ case AnnotationKind::method_id: {
if (is_get_method || genericsT_list || is_entrypoint || n_mutate_params || accepts_self) {
v_annotation->error("@method_id can be specified only for regular functions");
}
- f_declaration->method_id = v_annotation->get_arg()->get_item(0)->as<ast_int_const>();
+ auto v_int = v_annotation->get_arg()->get_item(0)->as<ast_int_const>();
+ if (v_int->intval.is_null() || !v_int->intval->signed_fits_bits(32)) {
+ v_int->error("invalid integer constant");
+ }
+ method_id = v_int->intval;
break;
+ }
case AnnotationKind::deprecated:
// no special handling
break;
@@ -1128,7 +1085,7 @@ static AnyV parse_function_declaration(Lexer& lex, const std::vector<V<ast_annot
}
}
- return f_declaration;
+ return createV<ast_function_declaration>(loc, v_ident, v_param_list, v_body, ret_type, genericsT_list, std::move(method_id), flags);
}
static AnyV parse_tolk_required_version(Lexer& lex) {
@@ -1142,10 +1099,10 @@ static AnyV parse_tolk_required_version(Lexer& lex) {
loc.show_warning("the contract is written in Tolk v" + semver + ", but you use Tolk compiler v" + TOLK_VERSION + "; probably, it will lead to compilation errors or hash changes");
}
- return createV<ast_tolk_required_version>(loc, tok_eq, semver); // semicolon is not necessary
+ return createV<ast_tolk_required_version>(loc, semver); // semicolon is not necessary
}
-static AnyV parse_import_statement(Lexer& lex) {
+static AnyV parse_import_directive(Lexer& lex) {
SrcLocation loc = lex.cur_location();
lex.expect(tok_import, "`import`");
lex.check(tok_string_const, "source file name");
@@ -1155,7 +1112,7 @@ static AnyV parse_import_statement(Lexer& lex) {
}
auto v_str = createV<ast_string_const>(lex.cur_location(), rel_filename, 0);
lex.next();
- return createV<ast_import_statement>(loc, v_str); // semicolon is not necessary
+ return createV<ast_import_directive>(loc, v_str); // semicolon is not necessary
}
// the main (exported) function
@@ -1176,7 +1133,7 @@ AnyV parse_src_file_to_ast(const SrcFile* file) {
if (!annotations.empty()) {
lex.unexpected("declaration after @annotations");
}
- toplevel_declarations.push_back(parse_import_statement(lex));
+ toplevel_declarations.push_back(parse_import_directive(lex));
break;
case tok_semicolon:
if (!annotations.empty()) {
diff --git a/tolk/ast-from-tokens.h b/tolk/ast-from-tokens.h
index 5f380c569..39574f9c2 100644
--- a/tolk/ast-from-tokens.h
+++ b/tolk/ast-from-tokens.h
@@ -16,12 +16,10 @@
*/
#pragma once
-#include "src-file.h"
+#include "fwd-declarations.h"
namespace tolk {
-struct ASTNodeBase;
-
-const ASTNodeBase* parse_src_file_to_ast(const SrcFile* file);
+AnyV parse_src_file_to_ast(const SrcFile* file);
} // namespace tolk
diff --git a/tolk/ast-replacer.h b/tolk/ast-replacer.h
index 478994e8b..c8350747c 100644
--- a/tolk/ast-replacer.h
+++ b/tolk/ast-replacer.h
@@ -35,25 +35,39 @@ namespace tolk {
class ASTReplacer {
protected:
- GNU_ATTRIBUTE_ALWAYS_INLINE static AnyV replace_children(const ASTNodeLeaf* v) {
+ GNU_ATTRIBUTE_ALWAYS_INLINE static AnyExprV replace_children(const ASTExprLeaf* v) {
return v;
}
- GNU_ATTRIBUTE_ALWAYS_INLINE AnyV replace_children(const ASTNodeUnary* v) {
- auto* v_mutable = const_cast<ASTNodeUnary*>(v);
+ GNU_ATTRIBUTE_ALWAYS_INLINE AnyExprV replace_children(const ASTExprUnary* v) {
+ auto* v_mutable = const_cast<ASTExprUnary*>(v);
v_mutable->child = replace(v_mutable->child);
return v_mutable;
}
- GNU_ATTRIBUTE_ALWAYS_INLINE AnyV replace_children(const ASTNodeBinary* v) {
- auto* v_mutable = const_cast<ASTNodeBinary*>(v);
+ GNU_ATTRIBUTE_ALWAYS_INLINE AnyExprV replace_children(const ASTExprBinary* v) {
+ auto* v_mutable = const_cast<ASTExprBinary*>(v);
v_mutable->lhs = replace(v->lhs);
v_mutable->rhs = replace(v->rhs);
return v_mutable;
}
- GNU_ATTRIBUTE_ALWAYS_INLINE AnyV replace_children(const ASTNodeVararg* v) {
- auto* v_mutable = const_cast<ASTNodeVararg*>(v);
+ GNU_ATTRIBUTE_ALWAYS_INLINE AnyExprV replace_children(const ASTExprVararg* v) {
+ auto* v_mutable = const_cast<ASTExprVararg*>(v);
+ for (AnyExprV& child : v_mutable->children) {
+ child = replace(child);
+ }
+ return v_mutable;
+ }
+
+ GNU_ATTRIBUTE_ALWAYS_INLINE AnyV replace_children(const ASTStatementUnary* v) {
+ auto* v_mutable = const_cast<ASTStatementUnary*>(v);
+ v_mutable->child = replace(v_mutable->child);
+ return v_mutable;
+ }
+
+ GNU_ATTRIBUTE_ALWAYS_INLINE AnyV replace_children(const ASTStatementVararg* v) {
+ auto* v_mutable = const_cast<ASTStatementVararg*>(v);
for (AnyV& child : v_mutable->children) {
child = replace(child);
}
@@ -64,97 +78,120 @@ class ASTReplacer {
virtual ~ASTReplacer() = default;
virtual AnyV replace(AnyV v) = 0;
+ virtual AnyExprV replace(AnyExprV v) = 0;
};
class ASTReplacerInFunctionBody : public ASTReplacer {
protected:
using parent = ASTReplacerInFunctionBody;
- virtual AnyV replace(V<ast_empty> v) { return replace_children(v); }
- virtual AnyV replace(V<ast_parenthesized_expr> v) { return replace_children(v); }
- virtual AnyV replace(V<ast_tensor> v) { return replace_children(v); }
- virtual AnyV replace(V<ast_tensor_square> v) { return replace_children(v); }
- virtual AnyV replace(V<ast_identifier> v) { return replace_children(v); }
- virtual AnyV replace(V<ast_int_const> v) { return replace_children(v); }
- virtual AnyV replace(V<ast_string_const> v) { return replace_children(v); }
- virtual AnyV replace(V<ast_bool_const> v) { return replace_children(v); }
- virtual AnyV replace(V<ast_null_keyword> v) { return replace_children(v); }
- virtual AnyV replace(V<ast_function_call> v) { return replace_children(v); }
- virtual AnyV replace(V<ast_dot_method_call> v) { return replace_children(v); }
- virtual AnyV replace(V<ast_underscore> v) { return replace_children(v); }
- virtual AnyV replace(V<ast_unary_operator> v) { return replace_children(v); }
- virtual AnyV replace(V<ast_binary_operator> v) { return replace_children(v); }
- virtual AnyV replace(V<ast_ternary_operator> v) { return replace_children(v); }
- virtual AnyV replace(V<ast_return_statement> v) { return replace_children(v); }
- virtual AnyV replace(V<ast_sequence> v) { return replace_children(v); }
- virtual AnyV replace(V<ast_repeat_statement> v) { return replace_children(v); }
- virtual AnyV replace(V<ast_while_statement> v) { return replace_children(v); }
- virtual AnyV replace(V<ast_do_while_statement> v) { return replace_children(v); }
- virtual AnyV replace(V<ast_throw_statement> v) { return replace_children(v); }
- virtual AnyV replace(V<ast_assert_statement> v) { return replace_children(v); }
- virtual AnyV replace(V<ast_try_catch_statement> v) { return replace_children(v); }
- virtual AnyV replace(V<ast_if_statement> v) { return replace_children(v); }
- virtual AnyV replace(V<ast_local_var> v) { return replace_children(v); }
- virtual AnyV replace(V<ast_local_vars_declaration> v) { return replace_children(v); }
- virtual AnyV replace(V<ast_asm_body> v) { return replace_children(v); }
-
- AnyV replace(AnyV v) final {
+ // expressions
+ virtual AnyExprV replace(V<ast_empty_expression> v) { return replace_children(v); }
+ virtual AnyExprV replace(V<ast_parenthesized_expression> v) { return replace_children(v); }
+ virtual AnyExprV replace(V<ast_tensor> v) { return replace_children(v); }
+ virtual AnyExprV replace(V<ast_typed_tuple> v) { return replace_children(v); }
+ virtual AnyExprV replace(V<ast_reference> v) { return replace_children(v); }
+ virtual AnyExprV replace(V<ast_local_var_lhs> v) { return replace_children(v); }
+ virtual AnyExprV replace(V<ast_local_vars_declaration> v) { return replace_children(v); }
+ virtual AnyExprV replace(V<ast_int_const> v) { return replace_children(v); }
+ virtual AnyExprV replace(V<ast_string_const> v) { return replace_children(v); }
+ virtual AnyExprV replace(V<ast_bool_const> v) { return replace_children(v); }
+ virtual AnyExprV replace(V<ast_null_keyword> v) { return replace_children(v); }
+ virtual AnyExprV replace(V<ast_argument> v) { return replace_children(v); }
+ virtual AnyExprV replace(V<ast_argument_list> v) { return replace_children(v); }
+ virtual AnyExprV replace(V<ast_dot_access> v) { return replace_children(v); }
+ virtual AnyExprV replace(V<ast_function_call> v) { return replace_children(v); }
+ virtual AnyExprV replace(V<ast_underscore> v) { return replace_children(v); }
+ virtual AnyExprV replace(V<ast_assign> v) { return replace_children(v); }
+ virtual AnyExprV replace(V<ast_set_assign> v) { return replace_children(v); }
+ virtual AnyExprV replace(V<ast_unary_operator> v) { return replace_children(v); }
+ virtual AnyExprV replace(V<ast_binary_operator> v) { return replace_children(v); }
+ virtual AnyExprV replace(V<ast_ternary_operator> v) { return replace_children(v); }
+ virtual AnyExprV replace(V<ast_cast_as_operator> v) { return replace_children(v); }
+ // statements
+ virtual AnyV replace(V<ast_empty_statement> v) { return replace_children(v); }
+ virtual AnyV replace(V<ast_sequence> v) { return replace_children(v); }
+ virtual AnyV replace(V<ast_return_statement> v) { return replace_children(v); }
+ virtual AnyV replace(V<ast_if_statement> v) { return replace_children(v); }
+ virtual AnyV replace(V<ast_repeat_statement> v) { return replace_children(v); }
+ virtual AnyV replace(V<ast_while_statement> v) { return replace_children(v); }
+ virtual AnyV replace(V<ast_do_while_statement> v) { return replace_children(v); }
+ virtual AnyV replace(V<ast_throw_statement> v) { return replace_children(v); }
+ virtual AnyV replace(V<ast_assert_statement> v) { return replace_children(v); }
+ virtual AnyV replace(V<ast_try_catch_statement> v) { return replace_children(v); }
+
+ AnyExprV replace(AnyExprV v) final {
switch (v->type) {
- case ast_empty: return replace(v->as<ast_empty>());
- case ast_parenthesized_expr: return replace(v->as<ast_parenthesized_expr>());
+ case ast_empty_expression: return replace(v->as<ast_empty_expression>());
+ case ast_parenthesized_expression: return replace(v->as<ast_parenthesized_expression>());
case ast_tensor: return replace(v->as<ast_tensor>());
- case ast_tensor_square: return replace(v->as<ast_tensor_square>());
- case ast_identifier: return replace(v->as<ast_identifier>());
+ case ast_typed_tuple: return replace(v->as<ast_typed_tuple>());
+ case ast_reference: return replace(v->as<ast_reference>());
+ case ast_local_var_lhs: return replace(v->as<ast_local_var_lhs>());
+ case ast_local_vars_declaration: return replace(v->as<ast_local_vars_declaration>());
case ast_int_const: return replace(v->as<ast_int_const>());
case ast_string_const: return replace(v->as<ast_string_const>());
case ast_bool_const: return replace(v->as<ast_bool_const>());
case ast_null_keyword: return replace(v->as<ast_null_keyword>());
- case ast_self_keyword: return replace(v->as<ast_self_keyword>());
+ case ast_argument: return replace(v->as<ast_argument>());
+ case ast_argument_list: return replace(v->as<ast_argument_list>());
+ case ast_dot_access: return replace(v->as<ast_dot_access>());
case ast_function_call: return replace(v->as<ast_function_call>());
- case ast_dot_method_call: return replace(v->as<ast_dot_method_call>());
case ast_underscore: return replace(v->as<ast_underscore>());
+ case ast_assign: return replace(v->as<ast_assign>());
+ case ast_set_assign: return replace(v->as<ast_set_assign>());
case ast_unary_operator: return replace(v->as<ast_unary_operator>());
case ast_binary_operator: return replace(v->as<ast_binary_operator>());
case ast_ternary_operator: return replace(v->as<ast_ternary_operator>());
- case ast_return_statement: return replace(v->as<ast_return_statement>());
+ case ast_cast_as_operator: return replace(v->as<ast_cast_as_operator>());
+ default:
+ throw UnexpectedASTNodeType(v, "ASTReplacerInFunctionBody::replace");
+ }
+ }
+
+ AnyV replace(AnyV v) final {
+ switch (v->type) {
+ case ast_empty_statement: return replace(v->as<ast_empty_statement>());
case ast_sequence: return replace(v->as<ast_sequence>());
+ case ast_return_statement: return replace(v->as<ast_return_statement>());
+ case ast_if_statement: return replace(v->as<ast_if_statement>());
case ast_repeat_statement: return replace(v->as<ast_repeat_statement>());
case ast_while_statement: return replace(v->as<ast_while_statement>());
case ast_do_while_statement: return replace(v->as<ast_do_while_statement>());
case ast_throw_statement: return replace(v->as<ast_throw_statement>());
case ast_assert_statement: return replace(v->as<ast_assert_statement>());
case ast_try_catch_statement: return replace(v->as<ast_try_catch_statement>());
- case ast_if_statement: return replace(v->as<ast_if_statement>());
- case ast_local_var: return replace(v->as<ast_local_var>());
- case ast_local_vars_declaration: return replace(v->as<ast_local_vars_declaration>());
- case ast_asm_body: return replace(v->as<ast_asm_body>());
- default:
- throw UnexpectedASTNodeType(v, "ASTReplacerInFunctionBody::visit");
+#ifdef TOLK_DEBUG
+ case ast_asm_body:
+ throw UnexpectedASTNodeType(v, "ASTReplacer::replace");
+#endif
+ default: {
+ // be very careful, don't forget to handle all statements (not expressions) above!
+ AnyExprV as_expr = reinterpret_cast<const ASTNodeExpressionBase*>(v);
+ return replace(as_expr);
+ }
}
}
public:
- void start_replacing_in_function(V<ast_function_declaration> v) {
- replace(v->get_body());
+ virtual bool should_visit_function(const FunctionData* fun_ref) = 0;
+
+ void start_replacing_in_function(const FunctionData* fun_ref, V<ast_function_declaration> v_function) {
+ replace(v_function->get_body());
}
};
-class ASTReplacerAllFunctionsInFile : public ASTReplacerInFunctionBody {
-protected:
- using parent = ASTReplacerAllFunctionsInFile;
- virtual bool should_enter_function(V<ast_function_declaration> v) = 0;
+const std::vector<const FunctionData*>& get_all_not_builtin_functions();
-public:
- void start_replacing_in_file(V<ast_tolk_file> v_file) {
- for (AnyV v : v_file->get_toplevel_declarations()) {
- if (auto v_function = v->try_as<ast_function_declaration>()) {
- if (should_enter_function(v_function)) {
- replace(v_function->get_body());
- }
- }
+template<class BodyReplacerT>
+void replace_ast_of_all_functions() {
+ BodyReplacerT visitor;
+ for (const FunctionData* fun_ref : get_all_not_builtin_functions()) {
+ if (visitor.should_visit_function(fun_ref)) {
+ visitor.start_replacing_in_function(fun_ref, fun_ref->ast_root->as<ast_function_declaration>());
}
}
-};
+}
} // namespace tolk
diff --git a/tolk/ast-replicator.h b/tolk/ast-replicator.h
new file mode 100644
index 000000000..02198adb8
--- /dev/null
+++ b/tolk/ast-replicator.h
@@ -0,0 +1,255 @@
+/*
+ This file is part of TON Blockchain Library.
+
+ TON Blockchain Library is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Lesser General Public License as published by
+ the Free Software Foundation, either version 2 of the License, or
+ (at your option) any later version.
+
+ TON Blockchain Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public License
+ along with TON Blockchain Library. If not, see <http://www.gnu.org/licenses/>.
+*/
+#pragma once
+
+#include "ast.h"
+#include "platform-utils.h"
+
+namespace tolk {
+
+class ASTReplicator {
+protected:
+ virtual AnyV clone(AnyV v) = 0;
+ virtual AnyExprV clone(AnyExprV v) = 0;
+ virtual TypePtr clone(TypePtr) = 0;
+
+public:
+ virtual ~ASTReplicator() = default;
+};
+
+class ASTReplicatorFunction : public ASTReplicator {
+protected:
+ using parent = ASTReplicatorFunction;
+
+ std::vector<AnyV> clone(const std::vector<AnyV>& items) {
+ std::vector<AnyV> result;
+ result.reserve(items.size());
+ for (AnyV item : items) {
+ result.push_back(clone(item));
+ }
+ return result;
+ }
+
+ std::vector<AnyExprV> clone(const std::vector<AnyExprV>& items) {
+ std::vector<AnyExprV> result;
+ result.reserve(items.size());
+ for (AnyExprV item : items) {
+ result.push_back(clone(item));
+ }
+ return result;
+ }
+
+ // expressions
+
+ virtual V<ast_empty_expression> clone(V<ast_empty_expression> v) {
+ return createV<ast_empty_expression>(v->loc);
+ }
+ virtual V<ast_parenthesized_expression> clone(V<ast_parenthesized_expression> v) {
+ return createV<ast_parenthesized_expression>(v->loc, clone(v->get_expr()));
+ }
+ virtual V<ast_tensor> clone(V<ast_tensor> v) {
+ return createV<ast_tensor>(v->loc, clone(v->get_items()));
+ }
+ virtual V<ast_typed_tuple> clone(V<ast_typed_tuple> v) {
+ return createV<ast_typed_tuple>(v->loc, clone(v->get_items()));
+ }
+ virtual V<ast_reference> clone(V<ast_reference> v) {
+ return createV<ast_reference>(v->loc, clone(v->get_identifier()), v->has_instantiationTs() ? clone(v->get_instantiationTs()) : nullptr);
+ }
+ virtual V<ast_local_var_lhs> clone(V<ast_local_var_lhs> v) {
+ return createV<ast_local_var_lhs>(v->loc, clone(v->get_identifier()), clone(v->declared_type), v->is_immutable, v->marked_as_redef);
+ }
+ virtual V<ast_local_vars_declaration> clone(V<ast_local_vars_declaration> v) {
+ return createV<ast_local_vars_declaration>(v->loc, clone(v->get_expr()));
+ }
+ virtual V<ast_int_const> clone(V<ast_int_const> v) {
+ return createV<ast_int_const>(v->loc, v->intval, v->orig_str);
+ }
+ virtual V<ast_string_const> clone(V<ast_string_const> v) {
+ return createV<ast_string_const>(v->loc, v->str_val, v->modifier);
+ }
+ virtual V<ast_bool_const> clone(V<ast_bool_const> v) {
+ return createV<ast_bool_const>(v->loc, v->bool_val);
+ }
+ virtual V<ast_null_keyword> clone(V<ast_null_keyword> v) {
+ return createV<ast_null_keyword>(v->loc);
+ }
+ virtual V<ast_argument> clone(V<ast_argument> v) {
+ return createV<ast_argument>(v->loc, clone(v->get_expr()), v->passed_as_mutate);
+ }
+ virtual V<ast_argument_list> clone(V<ast_argument_list> v) {
+ return createV<ast_argument_list>(v->loc, clone(v->get_arguments()));
+ }
+ virtual V<ast_dot_access> clone(V<ast_dot_access> v) {
+ return createV<ast_dot_access>(v->loc, clone(v->get_obj()), clone(v->get_identifier()), v->has_instantiationTs() ? clone(v->get_instantiationTs()) : nullptr);
+ }
+ virtual V<ast_function_call> clone(V<ast_function_call> v) {
+ return createV<ast_function_call>(v->loc, clone(v->get_callee()), clone(v->get_arg_list()));
+ }
+ virtual V<ast_underscore> clone(V<ast_underscore> v) {
+ return createV<ast_underscore>(v->loc);
+ }
+ virtual V<ast_assign> clone(V<ast_assign> v) {
+ return createV<ast_assign>(v->loc, clone(v->get_lhs()), clone(v->get_rhs()));
+ }
+ virtual V<ast_set_assign> clone(V<ast_set_assign> v) {
+ return createV<ast_set_assign>(v->loc, v->operator_name, v->tok, clone(v->get_lhs()), clone(v->get_rhs()));
+ }
+ virtual V<ast_unary_operator> clone(V<ast_unary_operator> v) {
+ return createV<ast_unary_operator>(v->loc, v->operator_name, v->tok, clone(v->get_rhs()));
+ }
+ virtual V<ast_binary_operator> clone(V<ast_binary_operator> v) {
+ return createV<ast_binary_operator>(v->loc, v->operator_name, v->tok, clone(v->get_lhs()), clone(v->get_rhs()));
+ }
+ virtual V<ast_ternary_operator> clone(V<ast_ternary_operator> v) {
+ return createV<ast_ternary_operator>(v->loc, clone(v->get_cond()), clone(v->get_when_true()), clone(v->get_when_false()));
+ }
+ virtual V<ast_cast_as_operator> clone(V<ast_cast_as_operator> v) {
+ return createV<ast_cast_as_operator>(v->loc, clone(v->get_expr()), clone(v->cast_to_type));
+ }
+
+ // statements
+
+ virtual V<ast_empty_statement> clone(V<ast_empty_statement> v) {
+ return createV<ast_empty_statement>(v->loc);
+ }
+ virtual V<ast_sequence> clone(V<ast_sequence> v) {
+ return createV<ast_sequence>(v->loc, v->loc_end, clone(v->get_items()));
+ }
+ virtual V<ast_return_statement> clone(V<ast_return_statement> v) {
+ return createV<ast_return_statement>(v->loc, clone(v->get_return_value()));
+ }
+ virtual V<ast_if_statement> clone(V<ast_if_statement> v) {
+ return createV<ast_if_statement>(v->loc, v->is_ifnot, clone(v->get_cond()), clone(v->get_if_body()), clone(v->get_else_body()));
+ }
+ virtual V<ast_repeat_statement> clone(V<ast_repeat_statement> v) {
+ return createV<ast_repeat_statement>(v->loc, clone(v->get_cond()), clone(v->get_body()));
+ }
+ virtual V<ast_while_statement> clone(V<ast_while_statement> v) {
+ return createV<ast_while_statement>(v->loc, clone(v->get_cond()), clone(v->get_body()));
+ }
+ virtual V<ast_do_while_statement> clone(V<ast_do_while_statement> v) {
+ return createV<ast_do_while_statement>(v->loc, clone(v->get_body()), clone(v->get_cond()));
+ }
+ virtual V<ast_throw_statement> clone(V<ast_throw_statement> v) {
+ return createV<ast_throw_statement>(v->loc, clone(v->get_thrown_code()), clone(v->get_thrown_arg()));
+ }
+ virtual V<ast_assert_statement> clone(V<ast_assert_statement> v) {
+ return createV<ast_assert_statement>(v->loc, clone(v->get_cond()), clone(v->get_thrown_code()));
+ }
+ virtual V<ast_try_catch_statement> clone(V<ast_try_catch_statement> v) {
+ return createV<ast_try_catch_statement>(v->loc, clone(v->get_try_body()), clone(v->get_catch_expr()), clone(v->get_catch_body()));
+ }
+ virtual V<ast_asm_body> clone(V<ast_asm_body> v) {
+ return createV<ast_asm_body>(v->loc, v->arg_order, v->ret_order, clone(v->get_asm_commands()));
+ }
+
+ // other
+
+ virtual V<ast_identifier> clone(V<ast_identifier> v) {
+ return createV<ast_identifier>(v->loc, v->name);
+ }
+ virtual V<ast_instantiationT_item> clone(V<ast_instantiationT_item> v) {
+ return createV<ast_instantiationT_item>(v->loc, clone(v->substituted_type));
+ }
+ virtual V<ast_instantiationT_list> clone(V<ast_instantiationT_list> v) {
+ return createV<ast_instantiationT_list>(v->loc, clone(v->get_items()));
+ }
+ virtual V<ast_parameter> clone(V<ast_parameter> v) {
+ return createV<ast_parameter>(v->loc, v->param_name, clone(v->declared_type), v->declared_as_mutate);
+ }
+ virtual V<ast_parameter_list> clone(V<ast_parameter_list> v) {
+ return createV<ast_parameter_list>(v->loc, clone(v->get_params()));
+ }
+
+ AnyExprV clone(AnyExprV v) final {
+ switch (v->type) {
+ case ast_empty_expression: return clone(v->as<ast_empty_expression>());
+ case ast_parenthesized_expression: return clone(v->as<ast_parenthesized_expression>());
+ case ast_tensor: return clone(v->as<ast_tensor>());
+ case ast_typed_tuple: return clone(v->as<ast_typed_tuple>());
+ case ast_reference: return clone(v->as<ast_reference>());
+ case ast_local_var_lhs: return clone(v->as<ast_local_var_lhs>());
+ case ast_local_vars_declaration: return clone(v->as<ast_local_vars_declaration>());
+ case ast_int_const: return clone(v->as<ast_int_const>());
+ case ast_string_const: return clone(v->as<ast_string_const>());
+ case ast_bool_const: return clone(v->as<ast_bool_const>());
+ case ast_null_keyword: return clone(v->as<ast_null_keyword>());
+ case ast_argument: return clone(v->as<ast_argument>());
+ case ast_argument_list: return clone(v->as<ast_argument_list>());
+ case ast_dot_access: return clone(v->as<ast_dot_access>());
+ case ast_function_call: return clone(v->as<ast_function_call>());
+ case ast_underscore: return clone(v->as<ast_underscore>());
+ case ast_assign: return clone(v->as<ast_assign>());
+ case ast_set_assign: return clone(v->as<ast_set_assign>());
+ case ast_unary_operator: return clone(v->as<ast_unary_operator>());
+ case ast_binary_operator: return clone(v->as<ast_binary_operator>());
+ case ast_ternary_operator: return clone(v->as<ast_ternary_operator>());
+ case ast_cast_as_operator: return clone(v->as<ast_cast_as_operator>());
+ default:
+ throw UnexpectedASTNodeType(v, "ASTReplicatorFunction::clone");
+ }
+ }
+
+ AnyV clone(AnyV v) final {
+ switch (v->type) {
+ case ast_empty_statement: return clone(v->as<ast_empty_statement>());
+ case ast_sequence: return clone(v->as<ast_sequence>());
+ case ast_return_statement: return clone(v->as<ast_return_statement>());
+ case ast_if_statement: return clone(v->as<ast_if_statement>());
+ case ast_repeat_statement: return clone(v->as<ast_repeat_statement>());
+ case ast_while_statement: return clone(v->as<ast_while_statement>());
+ case ast_do_while_statement: return clone(v->as<ast_do_while_statement>());
+ case ast_throw_statement: return clone(v->as<ast_throw_statement>());
+ case ast_assert_statement: return clone(v->as<ast_assert_statement>());
+ case ast_try_catch_statement: return clone(v->as<ast_try_catch_statement>());
+ case ast_asm_body: return clone(v->as<ast_asm_body>());
+ // other AST nodes that can be children of ast nodes of function body
+ case ast_identifier: return clone(v->as<ast_identifier>());
+ case ast_instantiationT_item: return clone(v->as<ast_instantiationT_item>());
+ case ast_instantiationT_list: return clone(v->as<ast_instantiationT_list>());
+ case ast_parameter: return clone(v->as<ast_parameter>());
+ case ast_parameter_list: return clone(v->as<ast_parameter_list>());
+
+ default: {
+ // be very careful, don't forget to handle all statements/other (not expressions) above!
+ AnyExprV as_expr = reinterpret_cast<const ASTNodeExpressionBase*>(v);
+ return clone(as_expr);
+ }
+ }
+ }
+
+ TypePtr clone(TypePtr t) override {
+ return t;
+ }
+
+ public:
+ virtual V<ast_function_declaration> clone_function_body(V<ast_function_declaration> v_function) {
+ return createV<ast_function_declaration>(
+ v_function->loc,
+ clone(v_function->get_identifier()),
+ clone(v_function->get_param_list()),
+ clone(v_function->get_body()->as<ast_sequence>()),
+ clone(v_function->declared_return_type),
+ v_function->genericsT_list,
+ v_function->method_id,
+ v_function->flags
+ );
+ }
+};
+
+} // namespace tolk
diff --git a/tolk/ast-stringifier.h b/tolk/ast-stringifier.h
index 759873b04..4ec72cddc 100644
--- a/tolk/ast-stringifier.h
+++ b/tolk/ast-stringifier.h
@@ -20,6 +20,7 @@
#include "ast.h"
#include "ast-visitor.h"
+#include "type-system.h"
#include <sstream>
/*
@@ -31,46 +32,55 @@ namespace tolk {
class ASTStringifier final : public ASTVisitor {
constexpr static std::pair<ASTNodeType, const char*> name_pairs[] = {
- {ast_empty, "ast_empty"},
- {ast_parenthesized_expr, "ast_parenthesized_expr"},
- {ast_tensor, "ast_tensor"},
- {ast_tensor_square, "ast_tensor_square"},
{ast_identifier, "ast_identifier"},
+ // expressions
+ {ast_empty_expression, "ast_empty_expression"},
+ {ast_parenthesized_expression, "ast_parenthesized_expression"},
+ {ast_tensor, "ast_tensor"},
+ {ast_typed_tuple, "ast_typed_tuple"},
+ {ast_reference, "ast_reference"},
+ {ast_local_var_lhs, "ast_local_var_lhs"},
+ {ast_local_vars_declaration, "ast_local_vars_declaration"},
{ast_int_const, "ast_int_const"},
{ast_string_const, "ast_string_const"},
{ast_bool_const, "ast_bool_const"},
{ast_null_keyword, "ast_null_keyword"},
- {ast_self_keyword, "ast_self_keyword"},
{ast_argument, "ast_argument"},
{ast_argument_list, "ast_argument_list"},
+ {ast_dot_access, "ast_dot_access"},
{ast_function_call, "ast_function_call"},
- {ast_dot_method_call, "ast_dot_method_call"},
- {ast_global_var_declaration, "ast_global_var_declaration"},
- {ast_constant_declaration, "ast_constant_declaration"},
{ast_underscore, "ast_underscore"},
+ {ast_assign, "ast_assign"},
+ {ast_set_assign, "ast_set_assign"},
{ast_unary_operator, "ast_unary_operator"},
{ast_binary_operator, "ast_binary_operator"},
{ast_ternary_operator, "ast_ternary_operator"},
- {ast_return_statement, "ast_return_statement"},
+ {ast_cast_as_operator, "ast_cast_as_operator"},
+ // statements
+ {ast_empty_statement, "ast_empty_statement"},
{ast_sequence, "ast_sequence"},
+ {ast_return_statement, "ast_return_statement"},
+ {ast_if_statement, "ast_if_statement"},
{ast_repeat_statement, "ast_repeat_statement"},
{ast_while_statement, "ast_while_statement"},
{ast_do_while_statement, "ast_do_while_statement"},
{ast_throw_statement, "ast_throw_statement"},
{ast_assert_statement, "ast_assert_statement"},
{ast_try_catch_statement, "ast_try_catch_statement"},
- {ast_if_statement, "ast_if_statement"},
+ {ast_asm_body, "ast_asm_body"},
+ // other
{ast_genericsT_item, "ast_genericsT_item"},
{ast_genericsT_list, "ast_genericsT_list"},
+ {ast_instantiationT_item, "ast_instantiationT_item"},
+ {ast_instantiationT_list, "ast_instantiationT_list"},
{ast_parameter, "ast_parameter"},
{ast_parameter_list, "ast_parameter_list"},
- {ast_asm_body, "ast_asm_body"},
{ast_annotation, "ast_annotation"},
{ast_function_declaration, "ast_function_declaration"},
- {ast_local_var, "ast_local_var"},
- {ast_local_vars_declaration, "ast_local_vars_declaration"},
+ {ast_global_var_declaration, "ast_global_var_declaration"},
+ {ast_constant_declaration, "ast_constant_declaration"},
{ast_tolk_required_version, "ast_tolk_required_version"},
- {ast_import_statement, "ast_import_statement"},
+ {ast_import_directive, "ast_import_directive"},
{ast_tolk_file, "ast_tolk_file"},
};
@@ -114,62 +124,94 @@ class ASTStringifier final : public ASTVisitor {
switch (v->type) {
case ast_identifier:
return static_cast<std::string>(v->as<ast_identifier>()->name);
+ case ast_reference: {
+ std::string result(v->as<ast_reference>()->get_name());
+ if (v->as<ast_reference>()->has_instantiationTs()) {
+ result += specific_str(v->as<ast_reference>()->get_instantiationTs());
+ }
+ return result;
+ }
case ast_int_const:
- return static_cast<std::string>(v->as<ast_int_const>()->int_val);
+ return static_cast<std::string>(v->as<ast_int_const>()->orig_str);
case ast_string_const:
if (char modifier = v->as<ast_string_const>()->modifier) {
return "\"" + static_cast<std::string>(v->as<ast_string_const>()->str_val) + "\"" + std::string(1, modifier);
} else {
return "\"" + static_cast<std::string>(v->as<ast_string_const>()->str_val) + "\"";
}
+ case ast_bool_const:
+ return v->as<ast_bool_const>()->bool_val ? "true" : "false";
+ case ast_dot_access: {
+ std::string result = "." + static_cast<std::string>(v->as<ast_dot_access>()->get_field_name());
+ if (v->as<ast_dot_access>()->has_instantiationTs()) {
+ result += specific_str(v->as<ast_dot_access>()->get_instantiationTs());
+ }
+ return result;
+ }
case ast_function_call: {
- if (auto v_lhs = v->as<ast_function_call>()->get_called_f()->try_as<ast_identifier>()) {
- return static_cast<std::string>(v_lhs->name) + "()";
+ std::string inner = specific_str(v->as<ast_function_call>()->get_callee());
+ if (int n_args = v->as<ast_function_call>()->get_num_args()) {
+ return inner + "(..." + std::to_string(n_args) + ")";
}
- return {};
+ return inner + "()";
}
- case ast_dot_method_call:
- return static_cast<std::string>(v->as<ast_dot_method_call>()->method_name);
case ast_global_var_declaration:
return static_cast<std::string>(v->as<ast_global_var_declaration>()->get_identifier()->name);
case ast_constant_declaration:
return static_cast<std::string>(v->as<ast_constant_declaration>()->get_identifier()->name);
+ case ast_assign:
+ return "=";
+ case ast_set_assign:
+ return static_cast<std::string>(v->as<ast_set_assign>()->operator_name) + "=";
case ast_unary_operator:
return static_cast<std::string>(v->as<ast_unary_operator>()->operator_name);
case ast_binary_operator:
return static_cast<std::string>(v->as<ast_binary_operator>()->operator_name);
+ case ast_cast_as_operator:
+ return v->as<ast_cast_as_operator>()->cast_to_type->as_human_readable();
case ast_sequence:
return "↓" + std::to_string(v->as<ast_sequence>()->get_items().size());
+ case ast_instantiationT_item:
+ return v->as<ast_instantiationT_item>()->substituted_type->as_human_readable();
case ast_if_statement:
return v->as<ast_if_statement>()->is_ifnot ? "ifnot" : "";
case ast_annotation:
return annotation_kinds[static_cast<int>(v->as<ast_annotation>()->kind)].second;
case ast_parameter: {
std::ostringstream os;
- os << v->as<ast_parameter>()->param_type;
- return static_cast<std::string>(v->as<ast_parameter>()->get_identifier()->name) + ": " + os.str();
+ os << v->as<ast_parameter>()->declared_type;
+ return static_cast<std::string>(v->as<ast_parameter>()->param_name) + ": " + os.str();
}
case ast_function_declaration: {
std::string param_names;
for (int i = 0; i < v->as<ast_function_declaration>()->get_num_params(); i++) {
if (!param_names.empty())
param_names += ",";
- param_names += v->as<ast_function_declaration>()->get_param(i)->get_identifier()->name;
+ param_names += v->as<ast_function_declaration>()->get_param(i)->param_name;
}
return "fun " + static_cast<std::string>(v->as<ast_function_declaration>()->get_identifier()->name) + "(" + param_names + ")";
}
- case ast_local_var: {
+ case ast_local_var_lhs: {
std::ostringstream os;
- os << v->as<ast_local_var>()->declared_type;
- if (auto v_ident = v->as<ast_local_var>()->get_identifier()->try_as<ast_identifier>()) {
- return static_cast<std::string>(v_ident->name) + ":" + os.str();
+ os << (v->as<ast_local_var_lhs>()->inferred_type ? v->as<ast_local_var_lhs>()->inferred_type : v->as<ast_local_var_lhs>()->declared_type);
+ if (v->as<ast_local_var_lhs>()->get_name().empty()) {
+ return "_: " + os.str();
+ }
+ return static_cast<std::string>(v->as<ast_local_var_lhs>()->get_name()) + ":" + os.str();
+ }
+ case ast_instantiationT_list: {
+ std::string result = "<";
+ for (AnyV item : v->as<ast_instantiationT_list>()->get_items()) {
+ if (result.size() > 1)
+ result += ",";
+ result += item->as<ast_instantiationT_item>()->substituted_type->as_human_readable();
}
- return "_: " + os.str();
+ return result + ">";
}
case ast_tolk_required_version:
return static_cast<std::string>(v->as<ast_tolk_required_version>()->semver);
- case ast_import_statement:
- return static_cast<std::string>(v->as<ast_import_statement>()->get_file_leaf()->str_val);
+ case ast_import_directive:
+ return static_cast<std::string>(v->as<ast_import_directive>()->get_file_leaf()->str_val);
case ast_tolk_file:
return v->as<ast_tolk_file>()->file->rel_filename;
default:
@@ -202,46 +244,55 @@ class ASTStringifier final : public ASTVisitor {
void visit(AnyV v) override {
switch (v->type) {
- case ast_empty: return handle_vertex(v->as<ast_empty>());
- case ast_parenthesized_expr: return handle_vertex(v->as<ast_parenthesized_expr>());
- case ast_tensor: return handle_vertex(v->as<ast_tensor>());
- case ast_tensor_square: return handle_vertex(v->as<ast_tensor_square>());
case ast_identifier: return handle_vertex(v->as<ast_identifier>());
+ // expressions
+ case ast_empty_expression: return handle_vertex(v->as<ast_empty_expression>());
+ case ast_parenthesized_expression: return handle_vertex(v->as<ast_parenthesized_expression>());
+ case ast_tensor: return handle_vertex(v->as<ast_tensor>());
+ case ast_typed_tuple: return handle_vertex(v->as<ast_typed_tuple>());
+ case ast_reference: return handle_vertex(v->as<ast_reference>());
+ case ast_local_var_lhs: return handle_vertex(v->as<ast_local_var_lhs>());
+ case ast_local_vars_declaration: return handle_vertex(v->as<ast_local_vars_declaration>());
case ast_int_const: return handle_vertex(v->as<ast_int_const>());
case ast_string_const: return handle_vertex(v->as<ast_string_const>());
case ast_bool_const: return handle_vertex(v->as<ast_bool_const>());
case ast_null_keyword: return handle_vertex(v->as<ast_null_keyword>());
- case ast_self_keyword: return handle_vertex(v->as<ast_self_keyword>());
case ast_argument: return handle_vertex(v->as<ast_argument>());
case ast_argument_list: return handle_vertex(v->as<ast_argument_list>());
+ case ast_dot_access: return handle_vertex(v->as<ast_dot_access>());
case ast_function_call: return handle_vertex(v->as<ast_function_call>());
- case ast_dot_method_call: return handle_vertex(v->as<ast_dot_method_call>());
- case ast_global_var_declaration: return handle_vertex(v->as<ast_global_var_declaration>());
- case ast_constant_declaration: return handle_vertex(v->as<ast_constant_declaration>());
case ast_underscore: return handle_vertex(v->as<ast_underscore>());
+ case ast_assign: return handle_vertex(v->as<ast_assign>());
+ case ast_set_assign: return handle_vertex(v->as<ast_set_assign>());
case ast_unary_operator: return handle_vertex(v->as<ast_unary_operator>());
case ast_binary_operator: return handle_vertex(v->as<ast_binary_operator>());
case ast_ternary_operator: return handle_vertex(v->as<ast_ternary_operator>());
- case ast_return_statement: return handle_vertex(v->as<ast_return_statement>());
+ case ast_cast_as_operator: return handle_vertex(v->as<ast_cast_as_operator>());
+ // statements
+ case ast_empty_statement: return handle_vertex(v->as<ast_empty_statement>());
case ast_sequence: return handle_vertex(v->as<ast_sequence>());
+ case ast_return_statement: return handle_vertex(v->as<ast_return_statement>());
+ case ast_if_statement: return handle_vertex(v->as<ast_if_statement>());
case ast_repeat_statement: return handle_vertex(v->as<ast_repeat_statement>());
case ast_while_statement: return handle_vertex(v->as<ast_while_statement>());
case ast_do_while_statement: return handle_vertex(v->as<ast_do_while_statement>());
case ast_throw_statement: return handle_vertex(v->as<ast_throw_statement>());
case ast_assert_statement: return handle_vertex(v->as<ast_assert_statement>());
case ast_try_catch_statement: return handle_vertex(v->as<ast_try_catch_statement>());
- case ast_if_statement: return handle_vertex(v->as<ast_if_statement>());
+ case ast_asm_body: return handle_vertex(v->as<ast_asm_body>());
+ // other
case ast_genericsT_item: return handle_vertex(v->as<ast_genericsT_item>());
case ast_genericsT_list: return handle_vertex(v->as<ast_genericsT_list>());
+ case ast_instantiationT_item: return handle_vertex(v->as<ast_instantiationT_item>());
+ case ast_instantiationT_list: return handle_vertex(v->as<ast_instantiationT_list>());
case ast_parameter: return handle_vertex(v->as<ast_parameter>());
case ast_parameter_list: return handle_vertex(v->as<ast_parameter_list>());
- case ast_asm_body: return handle_vertex(v->as<ast_asm_body>());
case ast_annotation: return handle_vertex(v->as<ast_annotation>());
case ast_function_declaration: return handle_vertex(v->as<ast_function_declaration>());
- case ast_local_var: return handle_vertex(v->as<ast_local_var>());
- case ast_local_vars_declaration: return handle_vertex(v->as<ast_local_vars_declaration>());
+ case ast_global_var_declaration: return handle_vertex(v->as<ast_global_var_declaration>());
+ case ast_constant_declaration: return handle_vertex(v->as<ast_constant_declaration>());
case ast_tolk_required_version: return handle_vertex(v->as<ast_tolk_required_version>());
- case ast_import_statement: return handle_vertex(v->as<ast_import_statement>());
+ case ast_import_directive: return handle_vertex(v->as<ast_import_directive>());
case ast_tolk_file: return handle_vertex(v->as<ast_tolk_file>());
default:
throw UnexpectedASTNodeType(v, "ASTStringifier::visit");
diff --git a/tolk/ast-visitor.h b/tolk/ast-visitor.h
index d0a7bfaf6..a54cb13be 100644
--- a/tolk/ast-visitor.h
+++ b/tolk/ast-visitor.h
@@ -37,20 +37,40 @@ namespace tolk {
class ASTVisitor {
protected:
- GNU_ATTRIBUTE_ALWAYS_INLINE static void visit_children(const ASTNodeLeaf* v) {
+ GNU_ATTRIBUTE_ALWAYS_INLINE static void visit_children(const ASTExprLeaf* v) {
static_cast<void>(v);
}
- GNU_ATTRIBUTE_ALWAYS_INLINE void visit_children(const ASTNodeUnary* v) {
+ GNU_ATTRIBUTE_ALWAYS_INLINE void visit_children(const ASTExprUnary* v) {
visit(v->child);
}
- GNU_ATTRIBUTE_ALWAYS_INLINE void visit_children(const ASTNodeBinary* v) {
+ GNU_ATTRIBUTE_ALWAYS_INLINE void visit_children(const ASTExprBinary* v) {
visit(v->lhs);
visit(v->rhs);
}
- GNU_ATTRIBUTE_ALWAYS_INLINE void visit_children(const ASTNodeVararg* v) {
+ GNU_ATTRIBUTE_ALWAYS_INLINE void visit_children(const ASTExprVararg* v) {
+ for (AnyExprV child : v->children) {
+ visit(child);
+ }
+ }
+
+ GNU_ATTRIBUTE_ALWAYS_INLINE void visit_children(const ASTStatementUnary* v) {
+ visit(v->child);
+ }
+
+ GNU_ATTRIBUTE_ALWAYS_INLINE void visit_children(const ASTStatementVararg* v) {
+ for (AnyV child : v->children) {
+ visit(child);
+ }
+ }
+
+ GNU_ATTRIBUTE_ALWAYS_INLINE static void visit_children(const ASTOtherLeaf* v) {
+ static_cast<void>(v);
+ }
+
+ GNU_ATTRIBUTE_ALWAYS_INLINE void visit_children(const ASTOtherVararg* v) {
for (AnyV child : v->children) {
visit(child);
}
@@ -66,90 +86,105 @@ class ASTVisitorFunctionBody : public ASTVisitor {
protected:
using parent = ASTVisitorFunctionBody;
- virtual void visit(V<ast_empty> v) { return visit_children(v); }
- virtual void visit(V<ast_parenthesized_expr> v) { return visit_children(v); }
+ // expressions
+ virtual void visit(V<ast_empty_expression> v) { return visit_children(v); }
+ virtual void visit(V<ast_parenthesized_expression> v) { return visit_children(v); }
virtual void visit(V<ast_tensor> v) { return visit_children(v); }
- virtual void visit(V<ast_tensor_square> v) { return visit_children(v); }
- virtual void visit(V<ast_identifier> v) { return visit_children(v); }
+ virtual void visit(V<ast_typed_tuple> v) { return visit_children(v); }
+ virtual void visit(V<ast_reference> v) { return visit_children(v); }
+ virtual void visit(V<ast_local_var_lhs> v) { return visit_children(v); }
+ virtual void visit(V<ast_local_vars_declaration> v) { return visit_children(v); }
virtual void visit(V<ast_int_const> v) { return visit_children(v); }
virtual void visit(V<ast_string_const> v) { return visit_children(v); }
virtual void visit(V<ast_bool_const> v) { return visit_children(v); }
virtual void visit(V<ast_null_keyword> v) { return visit_children(v); }
- virtual void visit(V<ast_self_keyword> v) { return visit_children(v); }
+ virtual void visit(V<ast_argument> v) { return visit_children(v); }
+ virtual void visit(V<ast_argument_list> v) { return visit_children(v); }
+ virtual void visit(V<ast_dot_access> v) { return visit_children(v); }
virtual void visit(V<ast_function_call> v) { return visit_children(v); }
- virtual void visit(V<ast_dot_method_call> v) { return visit_children(v); }
virtual void visit(V<ast_underscore> v) { return visit_children(v); }
+ virtual void visit(V<ast_assign> v) { return visit_children(v); }
+ virtual void visit(V<ast_set_assign> v) { return visit_children(v); }
virtual void visit(V<ast_unary_operator> v) { return visit_children(v); }
virtual void visit(V<ast_binary_operator> v) { return visit_children(v); }
virtual void visit(V<ast_ternary_operator> v) { return visit_children(v); }
- virtual void visit(V<ast_return_statement> v) { return visit_children(v); }
+ virtual void visit(V<ast_cast_as_operator> v) { return visit_children(v); }
+ // statements
+ virtual void visit(V<ast_empty_statement> v) { return visit_children(v); }
virtual void visit(V<ast_sequence> v) { return visit_children(v); }
+ virtual void visit(V<ast_return_statement> v) { return visit_children(v); }
+ virtual void visit(V<ast_if_statement> v) { return visit_children(v); }
virtual void visit(V<ast_repeat_statement> v) { return visit_children(v); }
virtual void visit(V<ast_while_statement> v) { return visit_children(v); }
virtual void visit(V<ast_do_while_statement> v) { return visit_children(v); }
+ virtual void visit(V<ast_throw_statement> v) { return visit_children(v); }
+ virtual void visit(V<ast_assert_statement> v) { return visit_children(v); }
virtual void visit(V<ast_try_catch_statement> v) { return visit_children(v); }
- virtual void visit(V<ast_if_statement> v) { return visit_children(v); }
- virtual void visit(V<ast_local_var> v) { return visit_children(v); }
- virtual void visit(V<ast_local_vars_declaration> v) { return visit_children(v); }
- virtual void visit(V<ast_asm_body> v) { return visit_children(v); }
void visit(AnyV v) final {
switch (v->type) {
- case ast_empty: return visit(v->as<ast_empty>());
- case ast_parenthesized_expr: return visit(v->as<ast_parenthesized_expr>());
+ // expressions
+ case ast_empty_expression: return visit(v->as<ast_empty_expression>());
+ case ast_parenthesized_expression: return visit(v->as<ast_parenthesized_expression>());
case ast_tensor: return visit(v->as<ast_tensor>());
- case ast_tensor_square: return visit(v->as<ast_tensor_square>());
- case ast_identifier: return visit(v->as<ast_identifier>());
+ case ast_typed_tuple: return visit(v->as<ast_typed_tuple>());
+ case ast_reference: return visit(v->as<ast_reference>());
+ case ast_local_var_lhs: return visit(v->as<ast_local_var_lhs>());
+ case ast_local_vars_declaration: return visit(v->as<ast_local_vars_declaration>());
case ast_int_const: return visit(v->as<ast_int_const>());
case ast_string_const: return visit(v->as<ast_string_const>());
case ast_bool_const: return visit(v->as<ast_bool_const>());
case ast_null_keyword: return visit(v->as<ast_null_keyword>());
- case ast_self_keyword: return visit(v->as<ast_self_keyword>());
+ case ast_argument: return visit(v->as<ast_argument>());
+ case ast_argument_list: return visit(v->as<ast_argument_list>());
+ case ast_dot_access: return visit(v->as<ast_dot_access>());
case ast_function_call: return visit(v->as<ast_function_call>());
- case ast_dot_method_call: return visit(v->as<ast_dot_method_call>());
case ast_underscore: return visit(v->as<ast_underscore>());
+ case ast_assign: return visit(v->as<ast_assign>());
+ case ast_set_assign: return visit(v->as<ast_set_assign>());
case ast_unary_operator: return visit(v->as<ast_unary_operator>());
case ast_binary_operator: return visit(v->as<ast_binary_operator>());
case ast_ternary_operator: return visit(v->as<ast_ternary_operator>());
- case ast_return_statement: return visit(v->as<ast_return_statement>());
+ case ast_cast_as_operator: return visit(v->as<ast_cast_as_operator>());
+ // statements
+ case ast_empty_statement: return visit(v->as<ast_empty_statement>());
case ast_sequence: return visit(v->as<ast_sequence>());
+ case ast_return_statement: return visit(v->as<ast_return_statement>());
+ case ast_if_statement: return visit(v->as<ast_if_statement>());
case ast_repeat_statement: return visit(v->as<ast_repeat_statement>());
case ast_while_statement: return visit(v->as<ast_while_statement>());
case ast_do_while_statement: return visit(v->as<ast_do_while_statement>());
case ast_throw_statement: return visit(v->as<ast_throw_statement>());
case ast_assert_statement: return visit(v->as<ast_assert_statement>());
case ast_try_catch_statement: return visit(v->as<ast_try_catch_statement>());
- case ast_if_statement: return visit(v->as<ast_if_statement>());
- case ast_local_var: return visit(v->as<ast_local_var>());
- case ast_local_vars_declaration: return visit(v->as<ast_local_vars_declaration>());
- case ast_asm_body: return visit(v->as<ast_asm_body>());
+#ifdef TOLK_DEBUG
+ case ast_asm_body:
+ throw UnexpectedASTNodeType(v, "ASTVisitor; forgot to filter out asm functions in should_visit_function()?");
+#endif
default:
throw UnexpectedASTNodeType(v, "ASTVisitorFunctionBody::visit");
}
}
public:
- void start_visiting_function(V<ast_function_declaration> v_function) {
+ virtual bool should_visit_function(const FunctionData* fun_ref) = 0;
+
+ virtual void start_visiting_function(const FunctionData* fun_ref, V<ast_function_declaration> v_function) {
visit(v_function->get_body());
}
};
-class ASTVisitorAllFunctionsInFile : public ASTVisitorFunctionBody {
-protected:
- using parent = ASTVisitorAllFunctionsInFile;
- virtual bool should_enter_function(V<ast_function_declaration> v) = 0;
+const std::vector<const FunctionData*>& get_all_not_builtin_functions();
-public:
- void start_visiting_file(V<ast_tolk_file> v_file) {
- for (AnyV v : v_file->get_toplevel_declarations()) {
- if (auto v_func = v->try_as<ast_function_declaration>()) {
- if (should_enter_function(v_func)) {
- visit(v_func->get_body());
- }
- }
+template<class BodyVisitorT>
+void visit_ast_of_all_functions() {
+ BodyVisitorT visitor;
+ for (const FunctionData* fun_ref : get_all_not_builtin_functions()) {
+ if (visitor.should_visit_function(fun_ref)) {
+ visitor.start_visiting_function(fun_ref, fun_ref->ast_root->as<ast_function_declaration>());
}
}
-};
+}
} // namespace tolk
diff --git a/tolk/ast.cpp b/tolk/ast.cpp
index b1af51005..092260ffc 100644
--- a/tolk/ast.cpp
+++ b/tolk/ast.cpp
@@ -15,8 +15,9 @@
along with TON Blockchain Library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "ast.h"
+#ifdef TOLK_DEBUG
#include "ast-stringifier.h"
-#include <iostream>
+#endif
namespace tolk {
@@ -79,7 +80,7 @@ int Vertex<ast_genericsT_list>::lookup_idx(std::string_view nameT) const {
int Vertex<ast_parameter_list>::lookup_idx(std::string_view param_name) const {
for (size_t idx = 0; idx < children.size(); ++idx) {
- if (children[idx] && children[idx]->as<ast_parameter>()->get_identifier()->name == param_name) {
+ if (children[idx] && children[idx]->as<ast_parameter>()->param_name == param_name) {
return static_cast<int>(idx);
}
}
@@ -96,8 +97,100 @@ int Vertex<ast_parameter_list>::get_mutate_params_count() const {
return n;
}
-void Vertex<ast_import_statement>::mutate_set_src_file(const SrcFile* file) const {
- const_cast<Vertex*>(this)->file = file;
+// ---------------------------------------------------------
+// "assign" methods
+//
+// From the user's point of view, all AST vertices are constant, fields are public, but can't be modified.
+// The only way to modify a field is to call "mutate()" and then use these "assign_*" methods.
+// Therefore, there is a guarantee, that all AST mutations are done via these methods,
+// easily searched by usages, and there is no another way to modify any other field.
+
+void ASTNodeExpressionBase::assign_inferred_type(TypePtr type) {
+ this->inferred_type = type;
+}
+
+void ASTNodeExpressionBase::assign_rvalue_true() {
+ this->is_rvalue = true;
+}
+
+void ASTNodeExpressionBase::assign_lvalue_true() {
+ this->is_lvalue = true;
+}
+
+void Vertex<ast_reference>::assign_sym(const Symbol* sym) {
+ this->sym = sym;
+}
+
+void Vertex<ast_function_call>::assign_fun_ref(const FunctionData* fun_ref) {
+ this->fun_maybe = fun_ref;
+}
+
+void Vertex<ast_cast_as_operator>::assign_resolved_type(TypePtr cast_to_type) {
+ this->cast_to_type = cast_to_type;
+}
+
+void Vertex<ast_global_var_declaration>::assign_var_ref(const GlobalVarData* var_ref) {
+ this->var_ref = var_ref;
+}
+
+void Vertex<ast_global_var_declaration>::assign_resolved_type(TypePtr declared_type) {
+ this->declared_type = declared_type;
+}
+
+void Vertex<ast_constant_declaration>::assign_const_ref(const GlobalConstData* const_ref) {
+ this->const_ref = const_ref;
+}
+
+void Vertex<ast_constant_declaration>::assign_resolved_type(TypePtr declared_type) {
+ this->declared_type = declared_type;
+}
+
+void Vertex<ast_instantiationT_item>::assign_resolved_type(TypePtr substituted_type) {
+ this->substituted_type = substituted_type;
+}
+
+void Vertex<ast_parameter>::assign_param_ref(const LocalVarData* param_ref) {
+ this->param_ref = param_ref;
+}
+
+void Vertex<ast_parameter>::assign_resolved_type(TypePtr declared_type) {
+ this->declared_type = declared_type;
+}
+
+void Vertex<ast_set_assign>::assign_fun_ref(const FunctionData* fun_ref) {
+ this->fun_ref = fun_ref;
+}
+
+void Vertex<ast_unary_operator>::assign_fun_ref(const FunctionData* fun_ref) {
+ this->fun_ref = fun_ref;
+}
+
+void Vertex<ast_binary_operator>::assign_fun_ref(const FunctionData* fun_ref) {
+ this->fun_ref = fun_ref;
+}
+
+void Vertex<ast_dot_access>::assign_target(const DotTarget& target) {
+ this->target = target;
+}
+
+void Vertex<ast_function_declaration>::assign_fun_ref(const FunctionData* fun_ref) {
+ this->fun_ref = fun_ref;
+}
+
+void Vertex<ast_function_declaration>::assign_resolved_type(TypePtr declared_return_type) {
+ this->declared_return_type = declared_return_type;
+}
+
+void Vertex<ast_local_var_lhs>::assign_var_ref(const LocalVarData* var_ref) {
+ this->var_ref = var_ref;
+}
+
+void Vertex<ast_local_var_lhs>::assign_resolved_type(TypePtr declared_type) {
+ this->declared_type = declared_type;
+}
+
+void Vertex<ast_import_directive>::assign_src_file(const SrcFile* file) {
+ this->file = file;
}
} // namespace tolk
diff --git a/tolk/ast.h b/tolk/ast.h
index fd2b27cbf..b90507e7e 100644
--- a/tolk/ast.h
+++ b/tolk/ast.h
@@ -17,10 +17,11 @@
#pragma once
#include <string>
+#include "fwd-declarations.h"
#include "platform-utils.h"
#include "src-file.h"
-#include "type-expr.h"
#include "lexer.h"
+#include "symtable.h"
/*
* Here we introduce AST representation of Tolk source code.
@@ -32,14 +33,18 @@
*
* From the user's point of view, all AST vertices are constant. All API is based on constancy.
* Even though fields of vertex structs are public, they can't be modified, since vertices are accepted by const ref.
- * Generally, there are two ways of accepting a vertex:
+ * Generally, there are three ways of accepting a vertex:
* * AnyV (= const ASTNodeBase*)
* the only you can do with this vertex is to see v->type (ASTNodeType) and to cast via v->as<node_type>()
+ * * AnyExprV (= const ASTNodeExpressionBase*)
+ * in contains expression-specific properties (lvalue/rvalue, inferred type)
* * V<node_type> (= const Vertex<node_type>*)
* a specific type of vertex, you can use its fields and methods
* There is one way of creating a vertex:
* * createV<node_type>(...constructor_args) (= new Vertex<node_type>(...))
* vertices are currently created on a heap, without any custom memory arena, just allocated and never deleted
+ * The only way to modify a field is to use "mutate()" method (drops constancy, the only point of mutation)
+ * and then to call "assign_*" method, like "assign_sym", "assign_src_file", etc.
*
* Having AnyV and knowing its node_type, a call
* v->as<node_type>()
@@ -59,46 +64,55 @@
namespace tolk {
enum ASTNodeType {
- ast_empty,
- ast_parenthesized_expr,
- ast_tensor,
- ast_tensor_square,
ast_identifier,
+ // expressions
+ ast_empty_expression,
+ ast_parenthesized_expression,
+ ast_tensor,
+ ast_typed_tuple,
+ ast_reference,
+ ast_local_var_lhs,
+ ast_local_vars_declaration,
ast_int_const,
ast_string_const,
ast_bool_const,
ast_null_keyword,
- ast_self_keyword,
ast_argument,
ast_argument_list,
+ ast_dot_access,
ast_function_call,
- ast_dot_method_call,
- ast_global_var_declaration,
- ast_constant_declaration,
ast_underscore,
+ ast_assign,
+ ast_set_assign,
ast_unary_operator,
ast_binary_operator,
ast_ternary_operator,
- ast_return_statement,
+ ast_cast_as_operator,
+ // statements
+ ast_empty_statement,
ast_sequence,
+ ast_return_statement,
+ ast_if_statement,
ast_repeat_statement,
ast_while_statement,
ast_do_while_statement,
ast_throw_statement,
ast_assert_statement,
ast_try_catch_statement,
- ast_if_statement,
+ ast_asm_body,
+ // other
ast_genericsT_item,
ast_genericsT_list,
+ ast_instantiationT_item,
+ ast_instantiationT_list,
ast_parameter,
ast_parameter_list,
- ast_asm_body,
ast_annotation,
ast_function_declaration,
- ast_local_var,
- ast_local_vars_declaration,
+ ast_global_var_declaration,
+ ast_constant_declaration,
ast_tolk_required_version,
- ast_import_statement,
+ ast_import_directive,
ast_tolk_file,
};
@@ -111,10 +125,6 @@ enum class AnnotationKind {
unknown,
};
-struct ASTNodeBase;
-
-using AnyV = const ASTNodeBase*;
-
template<ASTNodeType node_type>
struct Vertex;
@@ -141,6 +151,7 @@ struct ASTNodeBase {
const SrcLocation loc;
ASTNodeBase(ASTNodeType type, SrcLocation loc) : type(type), loc(loc) {}
+ ASTNodeBase(const ASTNodeBase&) = delete;
template<ASTNodeType node_type>
V<node_type> as() const {
@@ -157,7 +168,7 @@ struct ASTNodeBase {
return type == node_type ? static_cast<V<node_type>>(this) : nullptr;
}
- #ifdef TOLK_DEBUG
+#ifdef TOLK_DEBUG
std::string to_debug_string() const { return to_debug_string(false); }
std::string to_debug_string(bool colored) const;
void debug_print() const;
@@ -167,46 +178,123 @@ struct ASTNodeBase {
void error(const std::string& err_msg) const;
};
-struct ASTNodeLeaf : ASTNodeBase {
+struct ASTNodeExpressionBase : ASTNodeBase {
+ friend class ASTDuplicatorFunction;
+
+ TypePtr inferred_type = nullptr;
+ bool is_rvalue: 1 = false;
+ bool is_lvalue: 1 = false;
+
+ ASTNodeExpressionBase* mutate() const { return const_cast<ASTNodeExpressionBase*>(this); }
+ void assign_inferred_type(TypePtr type);
+ void assign_rvalue_true();
+ void assign_lvalue_true();
+
+ ASTNodeExpressionBase(ASTNodeType type, SrcLocation loc) : ASTNodeBase(type, loc) {}
+};
+
+struct ASTNodeStatementBase : ASTNodeBase {
+ ASTNodeStatementBase(ASTNodeType type, SrcLocation loc) : ASTNodeBase(type, loc) {}
+};
+
+struct ASTExprLeaf : ASTNodeExpressionBase {
friend class ASTVisitor;
friend class ASTReplacer;
protected:
- ASTNodeLeaf(ASTNodeType type, SrcLocation loc)
- : ASTNodeBase(type, loc) {}
+ ASTExprLeaf(ASTNodeType type, SrcLocation loc)
+ : ASTNodeExpressionBase(type, loc) {}
+};
+
+struct ASTExprUnary : ASTNodeExpressionBase {
+ friend class ASTVisitor;
+ friend class ASTReplacer;
+
+protected:
+ AnyExprV child;
+
+ ASTExprUnary(ASTNodeType type, SrcLocation loc, AnyExprV child)
+ : ASTNodeExpressionBase(type, loc), child(child) {}
+};
+
+struct ASTExprBinary : ASTNodeExpressionBase {
+ friend class ASTVisitor;
+ friend class ASTReplacer;
+
+protected:
+ AnyExprV lhs;
+ AnyExprV rhs;
+
+ ASTExprBinary(ASTNodeType type, SrcLocation loc, AnyExprV lhs, AnyExprV rhs)
+ : ASTNodeExpressionBase(type, loc), lhs(lhs), rhs(rhs) {}
+};
+
+struct ASTExprVararg : ASTNodeExpressionBase {
+ friend class ASTVisitor;
+ friend class ASTReplacer;
+
+protected:
+ std::vector<AnyExprV> children;
+
+ AnyExprV child(int i) const { return children.at(i); }
+
+ ASTExprVararg(ASTNodeType type, SrcLocation loc, std::vector<AnyExprV> children)
+ : ASTNodeExpressionBase(type, loc), children(std::move(children)) {}
+
+public:
+ int size() const { return static_cast<int>(children.size()); }
+ bool empty() const { return children.empty(); }
};
-struct ASTNodeUnary : ASTNodeBase {
+struct ASTStatementUnary : ASTNodeStatementBase {
friend class ASTVisitor;
friend class ASTReplacer;
protected:
AnyV child;
- ASTNodeUnary(ASTNodeType type, SrcLocation loc, AnyV child)
- : ASTNodeBase(type, loc), child(child) {}
+ AnyExprV child_as_expr() const { return reinterpret_cast<AnyExprV>(child); }
+
+ ASTStatementUnary(ASTNodeType type, SrcLocation loc, AnyV child)
+ : ASTNodeStatementBase(type, loc), child(child) {}
};
-struct ASTNodeBinary : ASTNodeBase {
+struct ASTStatementVararg : ASTNodeStatementBase {
friend class ASTVisitor;
friend class ASTReplacer;
protected:
- AnyV lhs;
- AnyV rhs;
+ std::vector<AnyV> children;
+
+ AnyExprV child_as_expr(int i) const { return reinterpret_cast<AnyExprV>(children.at(i)); }
+
+ ASTStatementVararg(ASTNodeType type, SrcLocation loc, std::vector<AnyV> children)
+ : ASTNodeStatementBase(type, loc), children(std::move(children)) {}
- ASTNodeBinary(ASTNodeType type, SrcLocation loc, AnyV lhs, AnyV rhs)
- : ASTNodeBase(type, loc), lhs(lhs), rhs(rhs) {}
+public:
+ int size() const { return static_cast<int>(children.size()); }
+ bool empty() const { return children.empty(); }
};
-struct ASTNodeVararg : ASTNodeBase {
+struct ASTOtherLeaf : ASTNodeBase {
+ friend class ASTVisitor;
+ friend class ASTReplacer;
+
+protected:
+ ASTOtherLeaf(ASTNodeType type, SrcLocation loc)
+ : ASTNodeBase(type, loc) {}
+};
+
+struct ASTOtherVararg : ASTNodeBase {
friend class ASTVisitor;
friend class ASTReplacer;
protected:
std::vector<AnyV> children;
- ASTNodeVararg(ASTNodeType type, SrcLocation loc, std::vector<AnyV> children)
+ AnyExprV child_as_expr(int i) const { return reinterpret_cast<AnyExprV>(children.at(i)); }
+
+ ASTOtherVararg(ASTNodeType type, SrcLocation loc, std::vector<AnyV> children)
: ASTNodeBase(type, loc), children(std::move(children)) {}
public:
@@ -214,312 +302,615 @@ struct ASTNodeVararg : ASTNodeBase {
bool empty() const { return children.empty(); }
};
+
+template<>
+// ast_identifier is "a name" in AST structure
+// it's NOT a standalone expression, it's "implementation details" of other AST vertices
+// example: `var x = 5` then "x" is identifier (inside local var declaration)
+// example: `global g: int` then "g" is identifier
+// example: `someF` is a reference, which contains identifier
+// example: `someF<int>` is a reference which contains identifier and generics instantiation
+// example: `fun f<T>()` then "f" is identifier, "<T>" is a generics declaration
+struct Vertex<ast_identifier> final : ASTOtherLeaf {
+ std::string_view name; // empty for underscore
+
+ Vertex(SrcLocation loc, std::string_view name)
+ : ASTOtherLeaf(ast_identifier, loc)
+ , name(name) {}
+};
+
+
+//
// ---------------------------------------------------------
+// expressions
+//
+
template<>
-struct Vertex<ast_empty> final : ASTNodeLeaf {
+// ast_empty_expression is "nothing" in context of expression, it has "unknown" type
+// example: `throw 123;` then "throw arg" is empty expression (opposed to `throw (123, arg)`)
+struct Vertex<ast_empty_expression> final : ASTExprLeaf {
explicit Vertex(SrcLocation loc)
- : ASTNodeLeaf(ast_empty, loc) {}
+ : ASTExprLeaf(ast_empty_expression, loc) {}
};
+
template<>
-struct Vertex<ast_parenthesized_expr> final : ASTNodeUnary {
- AnyV get_expr() const { return child; }
+// ast_parenthesized_expression is something surrounded embraced by (parenthesis)
+// example: `(1)`, `((f()))` (two nested)
+struct Vertex<ast_parenthesized_expression> final : ASTExprUnary {
+ AnyExprV get_expr() const { return child; }
- Vertex(SrcLocation loc, AnyV expr)
- : ASTNodeUnary(ast_parenthesized_expr, loc, expr) {}
+ Vertex(SrcLocation loc, AnyExprV expr)
+ : ASTExprUnary(ast_parenthesized_expression, loc, expr) {}
};
template<>
-struct Vertex<ast_tensor> final : ASTNodeVararg {
- const std::vector<AnyV>& get_items() const { return children; }
- AnyV get_item(int i) const { return children.at(i); }
+// ast_tensor is a set of expressions embraced by (parenthesis)
+// in most languages, it's called "tuple", but in TVM, "tuple" is a TVM primitive, that's why "tensor"
+// example: `(1, 2)`, `(1, (2, 3))` (nested), `()` (empty tensor)
+// note, that `(1)` is not a tensor, it's a parenthesized expression
+// a tensor of N elements occupies N slots on a stack (opposed to TVM tuple primitive, 1 slot)
+struct Vertex<ast_tensor> final : ASTExprVararg {
+ const std::vector<AnyExprV>& get_items() const { return children; }
+ AnyExprV get_item(int i) const { return child(i); }
+
+ Vertex(SrcLocation loc, std::vector<AnyExprV> items)
+ : ASTExprVararg(ast_tensor, loc, std::move(items)) {}
+};
- Vertex(SrcLocation loc, std::vector<AnyV> items)
- : ASTNodeVararg(ast_tensor, loc, std::move(items)) {}
+template<>
+// ast_typed_tuple is a set of expressions in [square brackets]
+// in TVM, it's a TVM tuple, that occupies 1 slot, but the compiler knows its "typed structure"
+// example: `[1, x]`, `[[0]]` (nested)
+// typed tuples can be assigned to N variables, like `[one, _, three] = [1,2,3]`
+struct Vertex<ast_typed_tuple> final : ASTExprVararg {
+ const std::vector<AnyExprV>& get_items() const { return children; }
+ AnyExprV get_item(int i) const { return child(i); }
+
+ Vertex(SrcLocation loc, std::vector<AnyExprV> items)
+ : ASTExprVararg(ast_typed_tuple, loc, std::move(items)) {}
};
template<>
-struct Vertex<ast_tensor_square> final : ASTNodeVararg {
- const std::vector<AnyV>& get_items() const { return children; }
- AnyV get_item(int i) const { return children.at(i); }
+// ast_reference is "something that references a symbol"
+// examples: `x` / `someF` / `someF<int>`
+// it's a leaf expression from traversing point of view, but actually, has children (not expressions)
+// note, that both `someF()` and `someF<int>()` are function calls, where a callee is just a reference
+struct Vertex<ast_reference> final : ASTExprLeaf {
+private:
+ V<ast_identifier> identifier; // its name, `x` / `someF`
+ V<ast_instantiationT_list> instantiationTs; // not null if `<int>`, otherwise nullptr
- Vertex(SrcLocation loc, std::vector<AnyV> items)
- : ASTNodeVararg(ast_tensor_square, loc, std::move(items)) {}
+public:
+ const Symbol* sym = nullptr; // filled on resolve or type inferring; points to local / global / function / constant
+
+ auto get_identifier() const { return identifier; }
+ bool has_instantiationTs() const { return instantiationTs != nullptr; }
+ auto get_instantiationTs() const { return instantiationTs; }
+ std::string_view get_name() const { return identifier->name; }
+
+ Vertex* mutate() const { return const_cast<Vertex*>(this); }
+ void assign_sym(const Symbol* sym);
+
+ Vertex(SrcLocation loc, V<ast_identifier> name_identifier, V<ast_instantiationT_list> instantiationTs)
+ : ASTExprLeaf(ast_reference, loc)
+ , identifier(name_identifier), instantiationTs(instantiationTs) {}
};
template<>
-struct Vertex<ast_identifier> final : ASTNodeLeaf {
- std::string_view name;
+// ast_local_var_lhs is one variable inside `var` declaration
+// example: `var x = 0;` then "x" is local var lhs
+// example: `val (x: int, [y redef], _) = rhs` then "x" and "y" and "_" are
+// it's a leaf from expression's point of view, though technically has an "identifier" child
+struct Vertex<ast_local_var_lhs> final : ASTExprLeaf {
+private:
+ V<ast_identifier> identifier;
- Vertex(SrcLocation loc, std::string_view name)
- : ASTNodeLeaf(ast_identifier, loc), name(name) {}
+public:
+ const LocalVarData* var_ref = nullptr; // filled on resolve identifiers; for `redef` points to declared above; for underscore, name is empty
+ TypePtr declared_type; // not null for `var x: int = rhs`, otherwise nullptr
+ bool is_immutable; // declared via 'val', not 'var'
+ bool marked_as_redef; // var (existing_var redef, new_var: int) = ...
+
+ V<ast_identifier> get_identifier() const { return identifier; }
+ std::string_view get_name() const { return identifier->name; } // empty for underscore
+
+ Vertex* mutate() const { return const_cast<Vertex*>(this); }
+ void assign_var_ref(const LocalVarData* var_ref);
+ void assign_resolved_type(TypePtr declared_type);
+
+ Vertex(SrcLocation loc, V<ast_identifier> identifier, TypePtr declared_type, bool is_immutable, bool marked_as_redef)
+ : ASTExprLeaf(ast_local_var_lhs, loc)
+ , identifier(identifier), declared_type(declared_type), is_immutable(is_immutable), marked_as_redef(marked_as_redef) {}
};
template<>
-struct Vertex<ast_int_const> final : ASTNodeLeaf {
- std::string_view int_val;
+// ast_local_vars_declaration is an expression declaring local variables on the left side of assignment
+// examples: see above
+// for `var (x, [y])` its expr is "tensor (local var, typed tuple (local var))"
+// for assignment `var x = 5`, this node is `var x`, lhs of assignment
+struct Vertex<ast_local_vars_declaration> final : ASTExprUnary {
+ AnyExprV get_expr() const { return child; } // ast_local_var_lhs / ast_tensor / ast_typed_tuple
+
+ Vertex(SrcLocation loc, AnyExprV expr)
+ : ASTExprUnary(ast_local_vars_declaration, loc, expr) {}
+};
- Vertex(SrcLocation loc, std::string_view int_val)
- : ASTNodeLeaf(ast_int_const, loc), int_val(int_val) {}
+template<>
+// ast_int_const is an integer literal
+// examples: `0` / `0xFF`
+// note, that `-1` is unary minus of `1` int const
+struct Vertex<ast_int_const> final : ASTExprLeaf {
+ td::RefInt256 intval; // parsed value, 255 for "0xFF"
+ std::string_view orig_str; // original "0xFF"; empty for nodes generated by compiler (e.g. in constant folding)
+
+ Vertex(SrcLocation loc, td::RefInt256 intval, std::string_view orig_str)
+ : ASTExprLeaf(ast_int_const, loc)
+ , intval(std::move(intval))
+ , orig_str(orig_str) {}
};
template<>
-struct Vertex<ast_string_const> final : ASTNodeLeaf {
+// ast_string_const is a string literal in double quotes or """ when multiline
+// examples: "asdf" / "Ef8zMz..."a / "to_calc_crc32_from"c
+// an optional modifier specifies how a string is parsed (probably, like an integer)
+// note, that TVM doesn't have strings, it has only slices, so "hello" has type slice
+struct Vertex<ast_string_const> final : ASTExprLeaf {
std::string_view str_val;
char modifier;
+ bool is_bitslice() const {
+ char m = modifier;
+ return m == 0 || m == 's' || m == 'a';
+ }
+ bool is_intval() const {
+ char m = modifier;
+ return m == 'u' || m == 'h' || m == 'H' || m == 'c';
+ }
+
Vertex(SrcLocation loc, std::string_view str_val, char modifier)
- : ASTNodeLeaf(ast_string_const, loc), str_val(str_val), modifier(modifier) {}
+ : ASTExprLeaf(ast_string_const, loc)
+ , str_val(str_val), modifier(modifier) {}
};
template<>
-struct Vertex<ast_bool_const> final : ASTNodeLeaf {
+// ast_bool_const is either `true` or `false`
+struct Vertex<ast_bool_const> final : ASTExprLeaf {
bool bool_val;
Vertex(SrcLocation loc, bool bool_val)
- : ASTNodeLeaf(ast_bool_const, loc), bool_val(bool_val) {}
+ : ASTExprLeaf(ast_bool_const, loc)
+ , bool_val(bool_val) {}
};
template<>
-struct Vertex<ast_null_keyword> final : ASTNodeLeaf {
+// ast_null_keyword is the `null` literal
+// it should be handled with care; for instance, `null` takes special place in the type system
+struct Vertex<ast_null_keyword> final : ASTExprLeaf {
explicit Vertex(SrcLocation loc)
- : ASTNodeLeaf(ast_null_keyword, loc) {}
+ : ASTExprLeaf(ast_null_keyword, loc) {}
};
template<>
-struct Vertex<ast_self_keyword> final : ASTNodeLeaf {
- explicit Vertex(SrcLocation loc)
- : ASTNodeLeaf(ast_self_keyword, loc) {}
+// ast_argument is an element of an argument list of a function/method call
+// example: `f(1, x)` has 2 arguments, `t.tupleFirst()` has no arguments (though `t` is passed as `self`)
+// example: `f(mutate arg)` has 1 argument with `passed_as_mutate` flag
+// (without `mutate` keyword, the entity "argument" could be replaced just by "any expression")
+struct Vertex<ast_argument> final : ASTExprUnary {
+ bool passed_as_mutate;
+
+ AnyExprV get_expr() const { return child; }
+
+ Vertex(SrcLocation loc, AnyExprV expr, bool passed_as_mutate)
+ : ASTExprUnary(ast_argument, loc, expr)
+ , passed_as_mutate(passed_as_mutate) {}
};
template<>
-struct Vertex<ast_argument> final : ASTNodeUnary {
- bool passed_as_mutate; // when called `f(mutate arg)`, not `f(arg)`
-
- AnyV get_expr() const { return child; }
+// ast_argument_list contains N arguments of a function/method call
+struct Vertex<ast_argument_list> final : ASTExprVararg {
+ const std::vector<AnyExprV>& get_arguments() const { return children; }
+ auto get_arg(int i) const { return child(i)->as<ast_argument>(); }
- explicit Vertex(SrcLocation loc, AnyV expr, bool passed_as_mutate)
- : ASTNodeUnary(ast_argument, loc, expr), passed_as_mutate(passed_as_mutate) {}
+ Vertex(SrcLocation loc, std::vector<AnyExprV> arguments)
+ : ASTExprVararg(ast_argument_list, loc, std::move(arguments)) {}
};
template<>
-struct Vertex<ast_argument_list> final : ASTNodeVararg {
- const std::vector<AnyV>& get_arguments() const { return children; }
- auto get_arg(int i) const { return children.at(i)->as<ast_argument>(); }
+// ast_dot_access is "object before dot, identifier + optional <T> after dot"
+// examples: `tensorVar.0` / `obj.field` / `getObj().method` / `t.tupleFirst<int>`
+// from traversing point of view, it's an unary expression: only obj is expression, field name is not
+// note, that `obj.method()` is a function call with "dot access `obj.method`" callee
+struct Vertex<ast_dot_access> final : ASTExprUnary {
+private:
+ V<ast_identifier> identifier; // `0` / `field` / `method`
+ V<ast_instantiationT_list> instantiationTs; // not null if `<int>`, otherwise nullptr
+
+public:
+
+ typedef const FunctionData* DotTarget; // for `t.tupleAt` target is `tupleAt` global function
+ DotTarget target = nullptr; // filled at type inferring
+
+ AnyExprV get_obj() const { return child; }
+ auto get_identifier() const { return identifier; }
+ bool has_instantiationTs() const { return instantiationTs != nullptr; }
+ auto get_instantiationTs() const { return instantiationTs; }
+ std::string_view get_field_name() const { return identifier->name; }
- explicit Vertex(SrcLocation loc, std::vector<AnyV> arguments)
- : ASTNodeVararg(ast_argument_list, loc, std::move(arguments)) {}
+ Vertex* mutate() const { return const_cast<Vertex*>(this); }
+ void assign_target(const DotTarget& target);
+
+ Vertex(SrcLocation loc, AnyExprV obj, V<ast_identifier> identifier, V<ast_instantiationT_list> instantiationTs)
+ : ASTExprUnary(ast_dot_access, loc, obj)
+ , identifier(identifier), instantiationTs(instantiationTs) {}
};
template<>
-struct Vertex<ast_function_call> final : ASTNodeBinary {
- AnyV get_called_f() const { return lhs; }
+// ast_function_call is "calling some lhs with parenthesis", lhs is arbitrary expression (callee)
+// example: `globalF()` then callee is reference
+// example: `globalF<int>()` then callee is reference (with instantiation Ts filled)
+// example: `local_var()` then callee is reference (points to local var, filled at resolve identifiers)
+// example: `getF()()` then callee is another func call (which type is TypeDataFunCallable)
+// example: `obj.method()` then callee is dot access (resolved while type inferring)
+struct Vertex<ast_function_call> final : ASTExprBinary {
+ const FunctionData* fun_maybe = nullptr; // filled while type inferring for `globalF()` / `obj.f()`; remains nullptr for `local_var()` / `getF()()`
+
+ AnyExprV get_callee() const { return lhs; }
+ bool is_dot_call() const { return lhs->type == ast_dot_access; }
+ AnyExprV get_dot_obj() const { return lhs->as<ast_dot_access>()->get_obj(); }
auto get_arg_list() const { return rhs->as<ast_argument_list>(); }
int get_num_args() const { return rhs->as<ast_argument_list>()->size(); }
auto get_arg(int i) const { return rhs->as<ast_argument_list>()->get_arg(i); }
- Vertex(SrcLocation loc, AnyV lhs_f, V<ast_argument_list> arguments)
- : ASTNodeBinary(ast_function_call, loc, lhs_f, arguments) {}
-};
+ Vertex* mutate() const { return const_cast<Vertex*>(this); }
+ void assign_fun_ref(const FunctionData* fun_ref);
-template<>
-struct Vertex<ast_dot_method_call> final : ASTNodeBinary {
- std::string_view method_name;
-
- AnyV get_obj() const { return lhs; }
- auto get_arg_list() const { return rhs->as<ast_argument_list>(); }
-
- Vertex(SrcLocation loc, std::string_view method_name, AnyV lhs, V<ast_argument_list> arguments)
- : ASTNodeBinary(ast_dot_method_call, loc, lhs, arguments), method_name(method_name) {}
+ Vertex(SrcLocation loc, AnyExprV lhs_f, V<ast_argument_list> arguments)
+ : ASTExprBinary(ast_function_call, loc, lhs_f, arguments) {}
};
template<>
-struct Vertex<ast_global_var_declaration> final : ASTNodeUnary {
- TypeExpr* declared_type; // may be nullptr
-
- auto get_identifier() const { return child->as<ast_identifier>(); }
-
- Vertex(SrcLocation loc, V<ast_identifier> name_identifier, TypeExpr* declared_type)
- : ASTNodeUnary(ast_global_var_declaration, loc, name_identifier), declared_type(declared_type) {}
+// ast_underscore represents `_` symbol used for left side of assignment
+// example: `(cs, _) = cs.loadAndReturn()`
+// though it's the only correct usage, using _ as rvalue like `var x = _;` is correct from AST point of view
+// note, that for declaration `var _ = 1` underscore is a regular local var declared (with empty name)
+// but for `_ = 1` (not declaration) it's underscore; it's because `var _:int` is also correct
+struct Vertex<ast_underscore> final : ASTExprLeaf {
+ explicit Vertex(SrcLocation loc)
+ : ASTExprLeaf(ast_underscore, loc) {}
};
template<>
-struct Vertex<ast_constant_declaration> final : ASTNodeBinary {
- TypeExpr* declared_type; // may be nullptr
-
- auto get_identifier() const { return lhs->as<ast_identifier>(); }
- AnyV get_init_value() const { return rhs; }
-
- Vertex(SrcLocation loc, V<ast_identifier> name_identifier, TypeExpr* declared_type, AnyV init_value)
- : ASTNodeBinary(ast_constant_declaration, loc, name_identifier, init_value), declared_type(declared_type) {}
+// ast_assign represents assignment "lhs = rhs"
+// examples: `a = 4` / `var a = 4` / `(cs, b, mode) = rhs` / `f() = g()`
+// note, that `a = 4` lhs is ast_reference, `var a = 4` lhs is ast_local_vars_declaration
+struct Vertex<ast_assign> final : ASTExprBinary {
+ AnyExprV get_lhs() const { return lhs; }
+ AnyExprV get_rhs() const { return rhs; }
+
+ explicit Vertex(SrcLocation loc, AnyExprV lhs, AnyExprV rhs)
+ : ASTExprBinary(ast_assign, loc, lhs, rhs) {}
};
template<>
-struct Vertex<ast_underscore> final : ASTNodeLeaf {
- explicit Vertex(SrcLocation loc)
- : ASTNodeLeaf(ast_underscore, loc) {}
+// ast_set_assign represents assignment-and-set operation "lhs <op>= rhs"
+// examples: `a += 4` / `b <<= c`
+struct Vertex<ast_set_assign> final : ASTExprBinary {
+ const FunctionData* fun_ref = nullptr; // filled at type inferring, points to `_+_` built-in for +=
+ std::string_view operator_name; // without equal sign, "+" for operator +=
+ TokenType tok; // tok_set_*
+
+ AnyExprV get_lhs() const { return lhs; }
+ AnyExprV get_rhs() const { return rhs; }
+
+ Vertex* mutate() const { return const_cast<Vertex*>(this); }
+ void assign_fun_ref(const FunctionData* fun_ref);
+
+ Vertex(SrcLocation loc, std::string_view operator_name, TokenType tok, AnyExprV lhs, AnyExprV rhs)
+ : ASTExprBinary(ast_set_assign, loc, lhs, rhs)
+ , operator_name(operator_name), tok(tok) {}
};
template<>
-struct Vertex<ast_unary_operator> final : ASTNodeUnary {
+// ast_unary_operator is "some operator over one expression"
+// examples: `-1` / `~found`
+struct Vertex<ast_unary_operator> final : ASTExprUnary {
+ const FunctionData* fun_ref = nullptr; // filled at type inferring, points to some built-in function
std::string_view operator_name;
TokenType tok;
- AnyV get_rhs() const { return child; }
+ AnyExprV get_rhs() const { return child; }
- Vertex(SrcLocation loc, std::string_view operator_name, TokenType tok, AnyV rhs)
- : ASTNodeUnary(ast_unary_operator, loc, rhs), operator_name(operator_name), tok(tok) {}
+ Vertex* mutate() const { return const_cast<Vertex*>(this); }
+ void assign_fun_ref(const FunctionData* fun_ref);
+
+ Vertex(SrcLocation loc, std::string_view operator_name, TokenType tok, AnyExprV rhs)
+ : ASTExprUnary(ast_unary_operator, loc, rhs)
+ , operator_name(operator_name), tok(tok) {}
};
template<>
-struct Vertex<ast_binary_operator> final : ASTNodeBinary {
+// ast_binary_operator is "some operator over two expressions"
+// examples: `a + b` / `x & true` / `(a, b) << g()`
+// note, that `a = b` is NOT a binary operator, it's ast_assign, also `a += b`, it's ast_set_assign
+struct Vertex<ast_binary_operator> final : ASTExprBinary {
+ const FunctionData* fun_ref = nullptr; // filled at type inferring, points to some built-in function
std::string_view operator_name;
TokenType tok;
- AnyV get_lhs() const { return lhs; }
- AnyV get_rhs() const { return rhs; }
+ AnyExprV get_lhs() const { return lhs; }
+ AnyExprV get_rhs() const { return rhs; }
+
+ Vertex* mutate() const { return const_cast<Vertex*>(this); }
+ void assign_fun_ref(const FunctionData* fun_ref);
- Vertex(SrcLocation loc, std::string_view operator_name, TokenType tok, AnyV lhs, AnyV rhs)
- : ASTNodeBinary(ast_binary_operator, loc, lhs, rhs), operator_name(operator_name), tok(tok) {}
+ Vertex(SrcLocation loc, std::string_view operator_name, TokenType tok, AnyExprV lhs, AnyExprV rhs)
+ : ASTExprBinary(ast_binary_operator, loc, lhs, rhs)
+ , operator_name(operator_name), tok(tok) {}
};
template<>
-struct Vertex<ast_ternary_operator> final : ASTNodeVararg {
- AnyV get_cond() const { return children.at(0); }
- AnyV get_when_true() const { return children.at(1); }
- AnyV get_when_false() const { return children.at(2); }
-
- Vertex(SrcLocation loc, AnyV cond, AnyV when_true, AnyV when_false)
- : ASTNodeVararg(ast_ternary_operator, loc, {cond, when_true, when_false}) {}
+// ast_ternary_operator is a traditional ternary construction
+// example: `cond ? a : b`
+struct Vertex<ast_ternary_operator> final : ASTExprVararg {
+ AnyExprV get_cond() const { return child(0); }
+ AnyExprV get_when_true() const { return child(1); }
+ AnyExprV get_when_false() const { return child(2); }
+
+ Vertex(SrcLocation loc, AnyExprV cond, AnyExprV when_true, AnyExprV when_false)
+ : ASTExprVararg(ast_ternary_operator, loc, {cond, when_true, when_false}) {}
};
template<>
-struct Vertex<ast_return_statement> : ASTNodeUnary {
- AnyV get_return_value() const { return child; }
+// ast_cast_as_operator is explicit casting with "as" keyword
+// examples: `arg as int` / `null as cell` / `t.tupleAt(2) as slice`
+struct Vertex<ast_cast_as_operator> final : ASTExprUnary {
+ AnyExprV get_expr() const { return child; }
+
+ TypePtr cast_to_type;
+
+ Vertex* mutate() const { return const_cast<Vertex*>(this); }
+ void assign_resolved_type(TypePtr cast_to_type);
+
+ Vertex(SrcLocation loc, AnyExprV expr, TypePtr cast_to_type)
+ : ASTExprUnary(ast_cast_as_operator, loc, expr)
+ , cast_to_type(cast_to_type) {}
+};
+
- Vertex(SrcLocation loc, AnyV child)
- : ASTNodeUnary(ast_return_statement, loc, child) {}
+//
+// ---------------------------------------------------------
+// statements
+//
+
+
+template<>
+// ast_empty_statement is very similar to "empty sequence" but has a special treatment
+// example: `;` (just semicolon)
+// example: body of `builtin` function is empty statement (not a zero sequence)
+struct Vertex<ast_empty_statement> final : ASTStatementVararg {
+ explicit Vertex(SrcLocation loc)
+ : ASTStatementVararg(ast_empty_statement, loc, {}) {}
};
template<>
-struct Vertex<ast_sequence> final : ASTNodeVararg {
+// ast_sequence is "some sequence of statements"
+// example: function body is a sequence
+// example: do while body is a sequence
+struct Vertex<ast_sequence> final : ASTStatementVararg {
SrcLocation loc_end;
const std::vector<AnyV>& get_items() const { return children; }
AnyV get_item(int i) const { return children.at(i); }
Vertex(SrcLocation loc, SrcLocation loc_end, std::vector<AnyV> items)
- : ASTNodeVararg(ast_sequence, loc, std::move(items)), loc_end(loc_end) {}
+ : ASTStatementVararg(ast_sequence, loc, std::move(items))
+ , loc_end(loc_end) {}
};
template<>
-struct Vertex<ast_repeat_statement> final : ASTNodeBinary {
- AnyV get_cond() const { return lhs; }
- auto get_body() const { return rhs->as<ast_sequence>(); }
-
- Vertex(SrcLocation loc, AnyV cond, V<ast_sequence> body)
- : ASTNodeBinary(ast_repeat_statement, loc, cond, body) {}
+// ast_return_statement is "return something from a function"
+// examples: `return a` / `return any_expr()()` / `return;`
+// note, that for `return;` (without a value, meaning "void"), in AST, it's stored as empty expression
+struct Vertex<ast_return_statement> : ASTStatementUnary {
+ AnyExprV get_return_value() const { return child_as_expr(); }
+ bool has_return_value() const { return child->type != ast_empty_expression; }
+
+ Vertex(SrcLocation loc, AnyExprV child)
+ : ASTStatementUnary(ast_return_statement, loc, child) {}
};
template<>
-struct Vertex<ast_while_statement> final : ASTNodeBinary {
- AnyV get_cond() const { return lhs; }
- auto get_body() const { return rhs->as<ast_sequence>(); }
+// ast_if_statement is a traditional if statement, probably followed by an else branch
+// examples: `if (cond) { ... } else { ... }` / `if (cond) { ... }`
+// when else branch is missing, it's stored as empty statement
+// for "else if", it's just "if statement" inside a sequence of else branch
+struct Vertex<ast_if_statement> final : ASTStatementVararg {
+ bool is_ifnot; // if(!cond), to generate more optimal fift code
+
+ AnyExprV get_cond() const { return child_as_expr(0); }
+ auto get_if_body() const { return children.at(1)->as<ast_sequence>(); }
+ auto get_else_body() const { return children.at(2)->as<ast_sequence>(); } // always exists (when else omitted, it's empty)
- Vertex(SrcLocation loc, AnyV cond, V<ast_sequence> body)
- : ASTNodeBinary(ast_while_statement, loc, cond, body) {}
+ Vertex(SrcLocation loc, bool is_ifnot, AnyExprV cond, V<ast_sequence> if_body, V<ast_sequence> else_body)
+ : ASTStatementVararg(ast_if_statement, loc, {cond, if_body, else_body})
+ , is_ifnot(is_ifnot) {}
};
template<>
-struct Vertex<ast_do_while_statement> final : ASTNodeBinary {
- auto get_body() const { return lhs->as<ast_sequence>(); }
- AnyV get_cond() const { return rhs; }
-
- Vertex(SrcLocation loc, V<ast_sequence> body, AnyV cond)
- : ASTNodeBinary(ast_do_while_statement, loc, body, cond) {}
+// ast_repeat_statement is "repeat something N times"
+// example: `repeat (10) { ... }`
+struct Vertex<ast_repeat_statement> final : ASTStatementVararg {
+ AnyExprV get_cond() const { return child_as_expr(0); }
+ auto get_body() const { return children.at(1)->as<ast_sequence>(); }
+
+ Vertex(SrcLocation loc, AnyExprV cond, V<ast_sequence> body)
+ : ASTStatementVararg(ast_repeat_statement, loc, {cond, body}) {}
};
template<>
-struct Vertex<ast_throw_statement> final : ASTNodeBinary {
- AnyV get_thrown_code() const { return lhs; }
- AnyV get_thrown_arg() const { return rhs; } // may be ast_empty
- bool has_thrown_arg() const { return rhs->type != ast_empty; }
+// ast_while_statement is a standard "while" loop
+// example: `while (x > 0) { ... }`
+struct Vertex<ast_while_statement> final : ASTStatementVararg {
+ AnyExprV get_cond() const { return child_as_expr(0); }
+ auto get_body() const { return children.at(1)->as<ast_sequence>(); }
+
+ Vertex(SrcLocation loc, AnyExprV cond, V<ast_sequence> body)
+ : ASTStatementVararg(ast_while_statement, loc, {cond, body}) {}
+};
- Vertex(SrcLocation loc, AnyV thrown_code, AnyV thrown_arg)
- : ASTNodeBinary(ast_throw_statement, loc, thrown_code, thrown_arg) {}
+template<>
+// ast_do_while_statement is a standard "do while" loop
+// example: `do { ... } while (x > 0);`
+struct Vertex<ast_do_while_statement> final : ASTStatementVararg {
+ auto get_body() const { return children.at(0)->as<ast_sequence>(); }
+ AnyExprV get_cond() const { return child_as_expr(1); }
+
+ Vertex(SrcLocation loc, V<ast_sequence> body, AnyExprV cond)
+ : ASTStatementVararg(ast_do_while_statement, loc, {body, cond}) {}
};
template<>
-struct Vertex<ast_assert_statement> final : ASTNodeBinary {
- AnyV get_cond() const { return lhs; }
- AnyV get_thrown_code() const { return rhs; }
+// ast_throw_statement is throwing an exception, it accepts excNo and optional arg
+// examples: `throw 10` / `throw (ERR_LOW_BALANCE)` / `throw (1001, incomingAddr)`
+// when thrown arg is missing, it's stored as empty expression
+struct Vertex<ast_throw_statement> final : ASTStatementVararg {
+ AnyExprV get_thrown_code() const { return child_as_expr(0); }
+ bool has_thrown_arg() const { return child_as_expr(1)->type != ast_empty_expression; }
+ AnyExprV get_thrown_arg() const { return child_as_expr(1); }
+
+ Vertex(SrcLocation loc, AnyExprV thrown_code, AnyExprV thrown_arg)
+ : ASTStatementVararg(ast_throw_statement, loc, {thrown_code, thrown_arg}) {}
+};
- Vertex(SrcLocation loc, AnyV cond, AnyV thrown_code)
- : ASTNodeBinary(ast_assert_statement, loc, cond, thrown_code) {}
+template<>
+// ast_assert_statement is "assert that cond is true, otherwise throw an exception"
+// examples: `assert (balance > 0, ERR_ZERO_BALANCE)` / `assert (balance > 0) throw (ERR_ZERO_BALANCE)`
+struct Vertex<ast_assert_statement> final : ASTStatementVararg {
+ AnyExprV get_cond() const { return child_as_expr(0); }
+ AnyExprV get_thrown_code() const { return child_as_expr(1); }
+
+ Vertex(SrcLocation loc, AnyExprV cond, AnyExprV thrown_code)
+ : ASTStatementVararg(ast_assert_statement, loc, {cond, thrown_code}) {}
};
template<>
-struct Vertex<ast_try_catch_statement> final : ASTNodeVararg {
+// ast_try_catch_statement is a standard try catch (finally block doesn't exist)
+// example: `try { ... } catch (excNo) { ... }`
+// there are two formal "arguments" of catch: excNo and arg, but both can be omitted
+// when omitted, they are stored as underscores, so len of a catch tensor is always 2
+struct Vertex<ast_try_catch_statement> final : ASTStatementVararg {
auto get_try_body() const { return children.at(0)->as<ast_sequence>(); }
auto get_catch_expr() const { return children.at(1)->as<ast_tensor>(); } // (excNo, arg), always len 2
auto get_catch_body() const { return children.at(2)->as<ast_sequence>(); }
Vertex(SrcLocation loc, V<ast_sequence> try_body, V<ast_tensor> catch_expr, V<ast_sequence> catch_body)
- : ASTNodeVararg(ast_try_catch_statement, loc, {try_body, catch_expr, catch_body}) {}
+ : ASTStatementVararg(ast_try_catch_statement, loc, {try_body, catch_expr, catch_body}) {}
};
template<>
-struct Vertex<ast_if_statement> final : ASTNodeVararg {
- bool is_ifnot; // if(!cond), to generate more optimal fift code
+// ast_asm_body is a body of `asm` function — a set of strings, and optionally stack order manipulations
+// example: `fun skipMessageOp... asm "32 PUSHINT" "SDSKIPFIRST";`
+// user can specify "arg order"; example: `fun store(self: builder, op: int) asm (op self)` then [1, 0]
+// user can specify "ret order"; example: `fun modDiv... asm(-> 1 0) "DIVMOD";` then [1, 0]
+struct Vertex<ast_asm_body> final : ASTStatementVararg {
+ std::vector<int> arg_order;
+ std::vector<int> ret_order;
- AnyV get_cond() const { return children.at(0); }
- auto get_if_body() const { return children.at(1)->as<ast_sequence>(); }
- auto get_else_body() const { return children.at(2)->as<ast_sequence>(); } // always exists (when else omitted, it's empty)
+ const std::vector<AnyV>& get_asm_commands() const { return children; } // ast_string_const[]
- Vertex(SrcLocation loc, bool is_ifnot, AnyV cond, V<ast_sequence> if_body, V<ast_sequence> else_body)
- : ASTNodeVararg(ast_if_statement, loc, {cond, if_body, else_body}), is_ifnot(is_ifnot) {}
+ Vertex(SrcLocation loc, std::vector<int> arg_order, std::vector<int> ret_order, std::vector<AnyV> asm_commands)
+ : ASTStatementVararg(ast_asm_body, loc, std::move(asm_commands))
+ , arg_order(std::move(arg_order)), ret_order(std::move(ret_order)) {}
};
+
+//
+// ---------------------------------------------------------
+// other
+//
+
+
template<>
-struct Vertex<ast_genericsT_item> final : ASTNodeLeaf {
- TypeExpr* created_type; // used to keep same pointer, since TypeExpr::new_var(i) always allocates
+// ast_genericsT_item is generics T at declaration
+// example: `fun f<T1, T2>` has a list of 2 generic Ts
+struct Vertex<ast_genericsT_item> final : ASTOtherLeaf {
std::string_view nameT;
- Vertex(SrcLocation loc, TypeExpr* created_type, std::string_view nameT)
- : ASTNodeLeaf(ast_genericsT_item, loc), created_type(created_type), nameT(nameT) {}
+ Vertex(SrcLocation loc, std::string_view nameT)
+ : ASTOtherLeaf(ast_genericsT_item, loc)
+ , nameT(nameT) {}
};
template<>
-struct Vertex<ast_genericsT_list> final : ASTNodeVararg {
+// ast_genericsT_list is a container for generics T at declaration
+// example: see above
+struct Vertex<ast_genericsT_list> final : ASTOtherVararg {
std::vector<AnyV> get_items() const { return children; }
auto get_item(int i) const { return children.at(i)->as<ast_genericsT_item>(); }
Vertex(SrcLocation loc, std::vector<AnyV> genericsT_items)
- : ASTNodeVararg(ast_genericsT_list, loc, std::move(genericsT_items)) {}
+ : ASTOtherVararg(ast_genericsT_list, loc, std::move(genericsT_items)) {}
int lookup_idx(std::string_view nameT) const;
};
+
template<>
-struct Vertex<ast_parameter> final : ASTNodeUnary {
- TypeExpr* param_type;
- bool declared_as_mutate; // declared as `mutate param_name`
+// ast_instantiationT_item is manual substitution of generic T used in code, mostly for func calls
+// examples: `g<int>()` / `t.tupleFirst<slice>()` / `f<(int, slice), builder>()`
+struct Vertex<ast_instantiationT_item> final : ASTOtherLeaf {
+ TypePtr substituted_type;
- auto get_identifier() const { return child->as<ast_identifier>(); } // for underscore, name is empty
- bool is_underscore() const { return child->as<ast_identifier>()->name.empty(); }
+ Vertex* mutate() const { return const_cast<Vertex*>(this); }
+ void assign_resolved_type(TypePtr substituted_type);
- Vertex(SrcLocation loc, V<ast_identifier> name_identifier, TypeExpr* param_type, bool declared_as_mutate)
- : ASTNodeUnary(ast_parameter, loc, name_identifier), param_type(param_type), declared_as_mutate(declared_as_mutate) {}
+ Vertex(SrcLocation loc, TypePtr substituted_type)
+ : ASTOtherLeaf(ast_instantiationT_item, loc)
+ , substituted_type(substituted_type) {}
};
template<>
-struct Vertex<ast_parameter_list> final : ASTNodeVararg {
+// ast_instantiationT_list is a container for generic T substitutions used in code
+// examples: see above
+struct Vertex<ast_instantiationT_list> final : ASTOtherVararg {
+ std::vector<AnyV> get_items() const { return children; }
+ auto get_item(int i) const { return children.at(i)->as<ast_instantiationT_item>(); }
+
+ Vertex(SrcLocation loc, std::vector<AnyV> instantiationTs)
+ : ASTOtherVararg(ast_instantiationT_list, loc, std::move(instantiationTs)) {}
+};
+
+template<>
+// ast_parameter is a parameter of a function in its declaration
+// example: `fun f(a: int, mutate b: slice)` has 2 parameters
+struct Vertex<ast_parameter> final : ASTOtherLeaf {
+ const LocalVarData* param_ref = nullptr; // filled on resolve identifiers
+ std::string_view param_name;
+ TypePtr declared_type;
+ bool declared_as_mutate; // declared as `mutate param_name`
+
+ bool is_underscore() const { return param_name.empty(); }
+
+ Vertex* mutate() const { return const_cast<Vertex*>(this); }
+ void assign_param_ref(const LocalVarData* param_ref);
+ void assign_resolved_type(TypePtr declared_type);
+
+ Vertex(SrcLocation loc, std::string_view param_name, TypePtr declared_type, bool declared_as_mutate)
+ : ASTOtherLeaf(ast_parameter, loc)
+ , param_name(param_name), declared_type(declared_type), declared_as_mutate(declared_as_mutate) {}
+};
+
+template<>
+// ast_parameter_list is a container of parameters
+// example: see above
+struct Vertex<ast_parameter_list> final : ASTOtherVararg {
const std::vector<AnyV>& get_params() const { return children; }
auto get_param(int i) const { return children.at(i)->as<ast_parameter>(); }
Vertex(SrcLocation loc, std::vector<AnyV> params)
- : ASTNodeVararg(ast_parameter_list, loc, std::move(params)) {}
+ : ASTOtherVararg(ast_parameter_list, loc, std::move(params)) {}
int lookup_idx(std::string_view param_name) const;
int get_mutate_params_count() const;
@@ -527,106 +918,132 @@ struct Vertex<ast_parameter_list> final : ASTNodeVararg {
};
template<>
-struct Vertex<ast_asm_body> final : ASTNodeVararg {
- std::vector<int> arg_order;
- std::vector<int> ret_order;
-
- const std::vector<AnyV>& get_asm_commands() const { return children; } // ast_string_const[]
-
- Vertex(SrcLocation loc, std::vector<int> arg_order, std::vector<int> ret_order, std::vector<AnyV> asm_commands)
- : ASTNodeVararg(ast_asm_body, loc, std::move(asm_commands)), arg_order(std::move(arg_order)), ret_order(std::move(ret_order)) {}
-};
-
-template<>
-struct Vertex<ast_annotation> final : ASTNodeUnary {
+// ast_annotation is @annotation above a declaration
+// example: `@pure fun ...`
+struct Vertex<ast_annotation> final : ASTOtherVararg {
AnnotationKind kind;
- auto get_arg() const { return child->as<ast_tensor>(); }
+ auto get_arg() const { return children.at(0)->as<ast_tensor>(); }
static AnnotationKind parse_kind(std::string_view name);
Vertex(SrcLocation loc, AnnotationKind kind, V<ast_tensor> arg_probably_empty)
- : ASTNodeUnary(ast_annotation, loc, arg_probably_empty), kind(kind) {}
+ : ASTOtherVararg(ast_annotation, loc, {arg_probably_empty})
+ , kind(kind) {}
};
template<>
-struct Vertex<ast_local_var> final : ASTNodeUnary {
- TypeExpr* declared_type;
- bool is_immutable; // declared via 'val', not 'var'
- bool marked_as_redef; // var (existing_var redef, new_var: int) = ...
+// ast_function_declaration is declaring a function/method
+// methods are still global functions, just accepting "self" first parameter
+// example: `fun f() { ... }`
+// functions can be generic, `fun f<T>(params) { ... }`
+// their body is either sequence (regular code function), or `asm`, or `builtin`
+struct Vertex<ast_function_declaration> final : ASTOtherVararg {
+ auto get_identifier() const { return children.at(0)->as<ast_identifier>(); }
+ int get_num_params() const { return children.at(1)->as<ast_parameter_list>()->size(); }
+ auto get_param_list() const { return children.at(1)->as<ast_parameter_list>(); }
+ auto get_param(int i) const { return children.at(1)->as<ast_parameter_list>()->get_param(i); }
+ AnyV get_body() const { return children.at(2); } // ast_sequence / ast_asm_body
+
+ const FunctionData* fun_ref = nullptr; // filled after register
+ TypePtr declared_return_type; // filled at ast parsing; if unspecified (nullptr), means "auto infer"
+ V<ast_genericsT_list> genericsT_list; // for non-generics it's nullptr
+ td::RefInt256 method_id; // specified via @method_id annotation
+ int flags; // from enum in FunctionData
+
+ bool is_asm_function() const { return children.at(2)->type == ast_asm_body; }
+ bool is_code_function() const { return children.at(2)->type == ast_sequence; }
+ bool is_builtin_function() const { return children.at(2)->type == ast_empty_statement; }
- AnyV get_identifier() const { return child; } // ast_identifier / ast_underscore
+ Vertex* mutate() const { return const_cast<Vertex*>(this); }
+ void assign_fun_ref(const FunctionData* fun_ref);
+ void assign_resolved_type(TypePtr declared_return_type);
- Vertex(SrcLocation loc, AnyV name_identifier, TypeExpr* declared_type, bool is_immutable, bool marked_as_redef)
- : ASTNodeUnary(ast_local_var, loc, name_identifier), declared_type(declared_type), is_immutable(is_immutable), marked_as_redef(marked_as_redef) {}
+ Vertex(SrcLocation loc, V<ast_identifier> name_identifier, V<ast_parameter_list> parameters, AnyV body, TypePtr declared_return_type, V<ast_genericsT_list> genericsT_list, td::RefInt256 method_id, int flags)
+ : ASTOtherVararg(ast_function_declaration, loc, {name_identifier, parameters, body})
+ , declared_return_type(declared_return_type), genericsT_list(genericsT_list), method_id(std::move(method_id)), flags(flags) {}
};
template<>
-struct Vertex<ast_local_vars_declaration> final : ASTNodeBinary {
- AnyV get_lhs() const { return lhs; } // ast_local_var / ast_tensor / ast_tensor_square
- AnyV get_assigned_val() const { return rhs; }
+// ast_global_var_declaration is declaring a global var, outside a function
+// example: `global g: int;`
+// note, that globals don't have default values, since there is no single "entrypoint" for a contract
+struct Vertex<ast_global_var_declaration> final : ASTOtherVararg {
+ const GlobalVarData* var_ref = nullptr; // filled after register
+ TypePtr declared_type; // filled always, typing globals is mandatory
+
+ auto get_identifier() const { return children.at(0)->as<ast_identifier>(); }
- Vertex(SrcLocation loc, AnyV lhs, AnyV assigned_val)
- : ASTNodeBinary(ast_local_vars_declaration, loc, lhs, assigned_val) {}
+ Vertex* mutate() const { return const_cast<Vertex*>(this); }
+ void assign_var_ref(const GlobalVarData* var_ref);
+ void assign_resolved_type(TypePtr declared_type);
+
+ Vertex(SrcLocation loc, V<ast_identifier> name_identifier, TypePtr declared_type)
+ : ASTOtherVararg(ast_global_var_declaration, loc, {name_identifier})
+ , declared_type(declared_type) {}
};
template<>
-struct Vertex<ast_function_declaration> final : ASTNodeVararg {
- auto get_identifier() const { return children.at(0)->as<ast_identifier>(); }
- int get_num_params() const { return children.at(1)->as<ast_parameter_list>()->size(); }
- auto get_param_list() const { return children.at(1)->as<ast_parameter_list>(); }
- auto get_param(int i) const { return children.at(1)->as<ast_parameter_list>()->get_param(i); }
- AnyV get_body() const { return children.at(2); } // ast_sequence / ast_asm_body
+// ast_constant_declaration is declaring a global constant, outside a function
+// example: `const op = 0x123;`
+struct Vertex<ast_constant_declaration> final : ASTOtherVararg {
+ const GlobalConstData* const_ref = nullptr; // filled after register
+ TypePtr declared_type; // not null for `const op: int = ...`
- TypeExpr* ret_type = nullptr;
- V<ast_genericsT_list> genericsT_list = nullptr;
- bool is_entrypoint = false;
- bool marked_as_pure = false;
- bool marked_as_builtin = false;
- bool marked_as_get_method = false;
- bool marked_as_inline = false;
- bool marked_as_inline_ref = false;
- bool accepts_self = false;
- bool returns_self = false;
- V<ast_int_const> method_id = nullptr;
+ auto get_identifier() const { return children.at(0)->as<ast_identifier>(); }
+ AnyExprV get_init_value() const { return child_as_expr(1); }
- bool is_asm_function() const { return children.at(2)->type == ast_asm_body; }
+ Vertex* mutate() const { return const_cast<Vertex*>(this); }
+ void assign_const_ref(const GlobalConstData* const_ref);
+ void assign_resolved_type(TypePtr declared_type);
- Vertex(SrcLocation loc, V<ast_identifier> name_identifier, V<ast_parameter_list> parameters, AnyV body)
- : ASTNodeVararg(ast_function_declaration, loc, {name_identifier, parameters, body}) {}
+ Vertex(SrcLocation loc, V<ast_identifier> name_identifier, TypePtr declared_type, AnyExprV init_value)
+ : ASTOtherVararg(ast_constant_declaration, loc, {name_identifier, init_value})
+ , declared_type(declared_type) {}
};
template<>
-struct Vertex<ast_tolk_required_version> final : ASTNodeLeaf {
- TokenType cmp_tok;
+// ast_tolk_required_version is a preamble fixating compiler's version at the top of the file
+// example: `tolk 0.6`
+// when compiler version mismatches, it means, that another compiler was earlier for that sources, a warning is emitted
+struct Vertex<ast_tolk_required_version> final : ASTOtherLeaf {
std::string_view semver;
- Vertex(SrcLocation loc, TokenType cmp_tok, std::string_view semver)
- : ASTNodeLeaf(ast_tolk_required_version, loc), cmp_tok(cmp_tok), semver(semver) {}
+ Vertex(SrcLocation loc, std::string_view semver)
+ : ASTOtherLeaf(ast_tolk_required_version, loc)
+ , semver(semver) {}
};
template<>
-struct Vertex<ast_import_statement> final : ASTNodeUnary {
- const SrcFile* file = nullptr; // assigned after includes have been resolved
+// ast_import_directive is an import at the top of the file
+// examples: `import "another.tolk"` / `import "@stdlib/tvm-dicts"`
+struct Vertex<ast_import_directive> final : ASTOtherVararg {
+ const SrcFile* file = nullptr; // assigned after imports have been resolved, just after parsing a file to ast
- auto get_file_leaf() const { return child->as<ast_string_const>(); }
+ auto get_file_leaf() const { return children.at(0)->as<ast_string_const>(); }
- std::string get_file_name() const { return static_cast<std::string>(child->as<ast_string_const>()->str_val); }
+ std::string get_file_name() const { return static_cast<std::string>(children.at(0)->as<ast_string_const>()->str_val); }
- void mutate_set_src_file(const SrcFile* file) const;
+ Vertex* mutate() const { return const_cast<Vertex*>(this); }
+ void assign_src_file(const SrcFile* file);
Vertex(SrcLocation loc, V<ast_string_const> file_name)
- : ASTNodeUnary(ast_import_statement, loc, file_name) {}
+ : ASTOtherVararg(ast_import_directive, loc, {file_name}) {}
};
template<>
-struct Vertex<ast_tolk_file> final : ASTNodeVararg {
+// ast_tolk_file represents a whole parsed input .tolk file
+// with functions, constants, etc.
+// particularly, it contains imports that lead to loading other files
+// a whole program consists of multiple parsed files, each of them has a parsed ast tree (stdlib is also parsed)
+struct Vertex<ast_tolk_file> final : ASTOtherVararg {
const SrcFile* const file;
const std::vector<AnyV>& get_toplevel_declarations() const { return children; }
Vertex(const SrcFile* file, std::vector<AnyV> toplevel_declarations)
- : ASTNodeVararg(ast_tolk_file, SrcLocation(file), std::move(toplevel_declarations)), file(file) {}
+ : ASTOtherVararg(ast_tolk_file, SrcLocation(file), std::move(toplevel_declarations))
+ , file(file) {}
};
} // namespace tolk
diff --git a/tolk/builtins.cpp b/tolk/builtins.cpp
index d18cfa644..d704ec4d3 100644
--- a/tolk/builtins.cpp
+++ b/tolk/builtins.cpp
@@ -16,86 +16,57 @@
*/
#include "tolk.h"
#include "compiler-state.h"
+#include "type-system.h"
+#include "generics-helpers.h"
namespace tolk {
using namespace std::literals::string_literals;
-/*
- *
- * SYMBOL VALUES
- *
- */
-
-SymDef* define_builtin_func_impl(const std::string& name, SymValAsmFunc* func_val) {
- sym_idx_t name_idx = G.symbols.lookup_add(name);
- SymDef* def = define_global_symbol(name_idx);
- tolk_assert(!def->value);
-
- def->value = func_val;
-#ifdef TOLK_DEBUG
- def->value->sym_name = name;
-#endif
- return def;
-}
-
-// given func_type = `(slice, int) -> slice` and func flags, create SymDef for parameters
+// given func_type = `(slice, int) -> slice` and func flags, create SymLocalVarOrParameter
// currently (see at the bottom) parameters of built-in functions are unnamed:
// built-in functions are created using a resulting type
-static std::vector<SymDef*> define_builtin_parameters(const TypeExpr* func_type, int func_flags) {
+static std::vector<LocalVarData> define_builtin_parameters(const std::vector<TypePtr>& params_types, int func_flags) {
// `loadInt()`, `storeInt()`: they accept `self` and mutate it; no other options available in built-ins for now
- bool is_mutate_self = func_flags & SymValFunc::flagHasMutateParams;
- // func_type a map (params_type -> ret_type), probably surrounded by forall (internal representation of <T>)
- TypeExpr* params_type = func_type->constr == TypeExpr::te_ForAll ? func_type->args[0]->args[0] : func_type->args[0];
- std::vector<SymDef*> parameters;
-
- if (params_type->constr == TypeExpr::te_Tensor) { // multiple parameters: it's a tensor
- parameters.reserve(params_type->args.size());
- for (int i = 0; i < static_cast<int>(params_type->args.size()); ++i) {
- SymDef* sym_def = define_parameter(i, {});
- SymValVariable* sym_val = new SymValVariable(i, params_type->args[i]);
- if (i == 0 && is_mutate_self) {
- sym_val->flags |= SymValVariable::flagMutateParameter;
- }
- sym_def->value = sym_val;
- parameters.emplace_back(sym_def);
- }
- } else { // single parameter
- SymDef* sym_def = define_parameter(0, {});
- SymValVariable* sym_val = new SymValVariable(0, params_type);
- if (is_mutate_self) {
- sym_val->flags |= SymValVariable::flagMutateParameter;
- }
- sym_def->value = sym_val;
- parameters.emplace_back(sym_def);
+ bool is_mutate_self = func_flags & FunctionData::flagHasMutateParams;
+ std::vector<LocalVarData> parameters;
+ parameters.reserve(params_types.size());
+
+ for (int i = 0; i < static_cast<int>(params_types.size()); ++i) {
+ LocalVarData p_sym("", {}, params_types[i], (i == 0 && is_mutate_self) * LocalVarData::flagMutateParameter, i);
+ parameters.push_back(std::move(p_sym));
}
return parameters;
}
-static SymDef* define_builtin_func(const std::string& name, TypeExpr* func_type, const simple_compile_func_t& func, int flags) {
- return define_builtin_func_impl(name, new SymValAsmFunc(define_builtin_parameters(func_type, flags), func_type, func, flags | SymValFunc::flagBuiltinFunction));
+static void define_builtin_func(const std::string& name, const std::vector<TypePtr>& params_types, TypePtr return_type, const GenericsDeclaration* genericTs, const simple_compile_func_t& func, int flags) {
+ auto* f_sym = new FunctionData(name, {}, return_type, define_builtin_parameters(params_types, flags), flags, genericTs, nullptr, new FunctionBodyBuiltin(func), nullptr);
+ G.symtable.add_function(f_sym);
}
-static SymDef* define_builtin_func(const std::string& name, TypeExpr* func_type, const AsmOp& macro, int flags) {
- return define_builtin_func_impl(name, new SymValAsmFunc(define_builtin_parameters(func_type, flags), func_type, make_simple_compile(macro), flags | SymValFunc::flagBuiltinFunction));
+static void define_builtin_func(const std::string& name, const std::vector<TypePtr>& params_types, TypePtr return_type, const GenericsDeclaration* genericTs, const AsmOp& macro, int flags) {
+ auto* f_sym = new FunctionData(name, {}, return_type, define_builtin_parameters(params_types, flags), flags, genericTs, nullptr, new FunctionBodyBuiltin(make_simple_compile(macro)), nullptr);
+ G.symtable.add_function(f_sym);
}
-static SymDef* define_builtin_func(const std::string& name, TypeExpr* func_type, const simple_compile_func_t& func, int flags,
- std::initializer_list<int> arg_order, std::initializer_list<int> ret_order) {
- return define_builtin_func_impl(name, new SymValAsmFunc(define_builtin_parameters(func_type, flags), func_type, func, flags | SymValFunc::flagBuiltinFunction, arg_order, ret_order));
+static void define_builtin_func(const std::string& name, const std::vector<TypePtr>& params_types, TypePtr return_type, const GenericsDeclaration* genericTs, const simple_compile_func_t& func, int flags,
+ std::initializer_list<int> arg_order, std::initializer_list<int> ret_order) {
+ auto* f_sym = new FunctionData(name, {}, return_type, define_builtin_parameters(params_types, flags), flags, genericTs, nullptr, new FunctionBodyBuiltin(func), nullptr);
+ f_sym->arg_order = arg_order;
+ f_sym->ret_order = ret_order;
+ G.symtable.add_function(f_sym);
}
-bool SymValAsmFunc::compile(AsmOpList& dest, std::vector<VarDescr>& out, std::vector<VarDescr>& in,
- SrcLocation where) const {
- if (simple_compile) {
- return dest.append(simple_compile(out, in, where));
- } else if (ext_compile) {
- return ext_compile(dest, out, in);
- } else {
- return false;
- }
+void FunctionBodyBuiltin::compile(AsmOpList& dest, std::vector<VarDescr>& out, std::vector<VarDescr>& in,
+ SrcLocation where) const {
+ dest.append(simple_compile(out, in, where));
}
+void FunctionBodyAsm::compile(AsmOpList& dest) const {
+ dest.append(ops);
+}
+
+
/*
*
* DEFINE BUILT-IN FUNCTIONS
@@ -504,7 +475,7 @@ AsmOp compile_unary_plus(std::vector<VarDescr>& res, std::vector<VarDescr>& args
return AsmOp::Nop();
}
-AsmOp compile_logical_not(std::vector<VarDescr>& res, std::vector<VarDescr>& args, SrcLocation where) {
+AsmOp compile_logical_not(std::vector<VarDescr>& res, std::vector<VarDescr>& args, SrcLocation where, bool for_int_arg) {
tolk_assert(res.size() == 1 && args.size() == 1);
VarDescr &r = res[0], &x = args[0];
if (x.is_int_const()) {
@@ -513,7 +484,9 @@ AsmOp compile_logical_not(std::vector<VarDescr>& res, std::vector<VarDescr>& arg
return push_const(r.int_const);
}
r.val = VarDescr::ValBool;
- return exec_op("0 EQINT", 1);
+ // for integers, `!var` is `var != 0`
+ // for booleans, `!var` can be shortened to `~var` (works the same for 0/-1 but consumes less)
+ return for_int_arg ? exec_op("0 EQINT", 1) : exec_op("NOT", 1);
}
AsmOp compile_bitwise_and(std::vector<VarDescr>& res, std::vector<VarDescr>& args, SrcLocation where) {
@@ -1076,7 +1049,7 @@ AsmOp compile_fetch_slice(std::vector<VarDescr>& res, std::vector<VarDescr>& arg
return exec_op(fetch ? "LDSLICEX" : "PLDSLICEX", 2, 1 + (unsigned)fetch);
}
-// fun at<X>(t: tuple, index: int): X asm "INDEXVAR";
+// fun tupleAt<X>(t: tuple, index: int): X asm "INDEXVAR";
AsmOp compile_tuple_at(std::vector<VarDescr>& res, std::vector<VarDescr>& args, SrcLocation) {
tolk_assert(args.size() == 2 && res.size() == 1);
auto& y = args[1];
@@ -1087,7 +1060,7 @@ AsmOp compile_tuple_at(std::vector<VarDescr>& res, std::vector<VarDescr>& args,
return exec_op("INDEXVAR", 2, 1);
}
-// fun __isNull<X>(X arg): int
+// fun __isNull<X>(X arg): bool
AsmOp compile_is_null(std::vector<VarDescr>& res, std::vector<VarDescr>& args, SrcLocation) {
tolk_assert(args.size() == 1 && res.size() == 1);
res[0].val = VarDescr::ValBool;
@@ -1098,143 +1071,188 @@ AsmOp compile_is_null(std::vector<VarDescr>& res, std::vector<VarDescr>& args, S
void define_builtins() {
using namespace std::placeholders;
- TypeExpr* Unit = TypeExpr::new_unit();
- TypeExpr* Int = TypeExpr::new_atomic(TypeExpr::_Int);
- TypeExpr* Slice = TypeExpr::new_atomic(TypeExpr::_Slice);
- TypeExpr* Builder = TypeExpr::new_atomic(TypeExpr::_Builder);
- TypeExpr* Tuple = TypeExpr::new_atomic(TypeExpr::_Tuple);
- TypeExpr* Int2 = TypeExpr::new_tensor({Int, Int});
- TypeExpr* Int3 = TypeExpr::new_tensor({Int, Int, Int});
- TypeExpr* TupleInt = TypeExpr::new_tensor({Tuple, Int});
- TypeExpr* SliceInt = TypeExpr::new_tensor({Slice, Int});
- TypeExpr* X = TypeExpr::new_var(0);
- TypeExpr* arith_bin_op = TypeExpr::new_map(Int2, Int);
- TypeExpr* arith_un_op = TypeExpr::new_map(Int, Int);
- TypeExpr* impure_un_op = TypeExpr::new_map(Int, Unit);
- TypeExpr* fetch_int_op_mutate = TypeExpr::new_map(SliceInt, SliceInt);
- TypeExpr* prefetch_int_op = TypeExpr::new_map(SliceInt, Int);
- TypeExpr* store_int_mutate = TypeExpr::new_map(TypeExpr::new_tensor({Builder, Int, Int}), TypeExpr::new_tensor({Builder, Unit}));
- TypeExpr* fetch_slice_op_mutate = TypeExpr::new_map(SliceInt, TypeExpr::new_tensor({Slice, Slice}));
- TypeExpr* prefetch_slice_op = TypeExpr::new_map(SliceInt, Slice);
- TypeExpr* throw_arg_op = TypeExpr::new_forall({X}, TypeExpr::new_map(TypeExpr::new_tensor({X, Int}), Unit));
-
- define_builtin_func("_+_", arith_bin_op, compile_add,
- SymValFunc::flagMarkedAsPure);
- define_builtin_func("_-_", arith_bin_op, compile_sub,
- SymValFunc::flagMarkedAsPure);
- define_builtin_func("-_", arith_un_op, compile_unary_minus,
- SymValFunc::flagMarkedAsPure);
- define_builtin_func("+_", arith_un_op, compile_unary_plus,
- SymValFunc::flagMarkedAsPure);
- define_builtin_func("_*_", arith_bin_op, compile_mul,
- SymValFunc::flagMarkedAsPure);
- define_builtin_func("_/_", arith_bin_op, std::bind(compile_div, _1, _2, _3, -1),
- SymValFunc::flagMarkedAsPure);
- define_builtin_func("_~/_", arith_bin_op, std::bind(compile_div, _1, _2, _3, 0),
- SymValFunc::flagMarkedAsPure);
- define_builtin_func("_^/_", arith_bin_op, std::bind(compile_div, _1, _2, _3, 1),
- SymValFunc::flagMarkedAsPure);
- define_builtin_func("_%_", arith_bin_op, std::bind(compile_mod, _1, _2, _3, -1),
- SymValFunc::flagMarkedAsPure);
- define_builtin_func("_<<_", arith_bin_op, compile_lshift,
- SymValFunc::flagMarkedAsPure);
- define_builtin_func("_>>_", arith_bin_op, std::bind(compile_rshift, _1, _2, _3, -1),
- SymValFunc::flagMarkedAsPure);
- define_builtin_func("_~>>_", arith_bin_op, std::bind(compile_rshift, _1, _2, _3, 0),
- SymValFunc::flagMarkedAsPure);
- define_builtin_func("_^>>_", arith_bin_op, std::bind(compile_rshift, _1, _2, _3, 1),
- SymValFunc::flagMarkedAsPure);
- define_builtin_func("!_", arith_un_op, compile_logical_not,
- SymValFunc::flagMarkedAsPure);
- define_builtin_func("~_", arith_un_op, compile_bitwise_not,
- SymValFunc::flagMarkedAsPure);
- define_builtin_func("_&_", arith_bin_op, compile_bitwise_and,
- SymValFunc::flagMarkedAsPure);
- define_builtin_func("_|_", arith_bin_op, compile_bitwise_or,
- SymValFunc::flagMarkedAsPure);
- define_builtin_func("_^_", arith_bin_op, compile_bitwise_xor,
- SymValFunc::flagMarkedAsPure);
- define_builtin_func("^_+=_", arith_bin_op, compile_add,
- SymValFunc::flagMarkedAsPure);
- define_builtin_func("^_-=_", arith_bin_op, compile_sub,
- SymValFunc::flagMarkedAsPure);
- define_builtin_func("^_*=_", arith_bin_op, compile_mul,
- SymValFunc::flagMarkedAsPure);
- define_builtin_func("^_/=_", arith_bin_op, std::bind(compile_div, _1, _2, _3, -1),
- SymValFunc::flagMarkedAsPure);
- define_builtin_func("^_%=_", arith_bin_op, std::bind(compile_mod, _1, _2, _3, -1),
- SymValFunc::flagMarkedAsPure);
- define_builtin_func("^_<<=_", arith_bin_op, compile_lshift,
- SymValFunc::flagMarkedAsPure);
- define_builtin_func("^_>>=_", arith_bin_op, std::bind(compile_rshift, _1, _2, _3, -1),
- SymValFunc::flagMarkedAsPure);
- define_builtin_func("^_&=_", arith_bin_op, compile_bitwise_and,
- SymValFunc::flagMarkedAsPure);
- define_builtin_func("^_|=_", arith_bin_op, compile_bitwise_or,
- SymValFunc::flagMarkedAsPure);
- define_builtin_func("^_^=_", arith_bin_op, compile_bitwise_xor,
- SymValFunc::flagMarkedAsPure);
- define_builtin_func("_==_", arith_bin_op, std::bind(compile_cmp_int, _1, _2, 2),
- SymValFunc::flagMarkedAsPure);
- define_builtin_func("_!=_", arith_bin_op, std::bind(compile_cmp_int, _1, _2, 5),
- SymValFunc::flagMarkedAsPure);
- define_builtin_func("_<_", arith_bin_op, std::bind(compile_cmp_int, _1, _2, 4),
- SymValFunc::flagMarkedAsPure);
- define_builtin_func("_>_", arith_bin_op, std::bind(compile_cmp_int, _1, _2, 1),
- SymValFunc::flagMarkedAsPure);
- define_builtin_func("_<=_", arith_bin_op, std::bind(compile_cmp_int, _1, _2, 6),
- SymValFunc::flagMarkedAsPure);
- define_builtin_func("_>=_", arith_bin_op, std::bind(compile_cmp_int, _1, _2, 3),
- SymValFunc::flagMarkedAsPure);
- define_builtin_func("_<=>_", arith_bin_op, std::bind(compile_cmp_int, _1, _2, 7),
- SymValFunc::flagMarkedAsPure);
- define_builtin_func("mulDivFloor", TypeExpr::new_map(Int3, Int), std::bind(compile_muldiv, _1, _2, _3, -1),
- SymValFunc::flagMarkedAsPure);
- define_builtin_func("mulDivRound", TypeExpr::new_map(Int3, Int), std::bind(compile_muldiv, _1, _2, _3, 0),
- SymValFunc::flagMarkedAsPure);
- define_builtin_func("mulDivCeil", TypeExpr::new_map(Int3, Int), std::bind(compile_muldiv, _1, _2, _3, 1),
- SymValFunc::flagMarkedAsPure);
- define_builtin_func("mulDivMod", TypeExpr::new_map(Int3, Int2), AsmOp::Custom("MULDIVMOD", 3, 2),
- SymValFunc::flagMarkedAsPure);
- define_builtin_func("__true", TypeExpr::new_map(TypeExpr::new_unit(), Int), /* AsmOp::Const("TRUE") */ std::bind(compile_bool_const, _1, _2, true),
- SymValFunc::flagMarkedAsPure);
- define_builtin_func("__false", TypeExpr::new_map(TypeExpr::new_unit(), Int), /* AsmOp::Const("FALSE") */ std::bind(compile_bool_const, _1, _2, false),
- SymValFunc::flagMarkedAsPure);
- define_builtin_func("__null", TypeExpr::new_forall({X}, TypeExpr::new_map(TypeExpr::new_unit(), X)), AsmOp::Const("PUSHNULL"),
- SymValFunc::flagMarkedAsPure);
- define_builtin_func("__isNull", TypeExpr::new_forall({X}, TypeExpr::new_map(X, Int)), compile_is_null,
- SymValFunc::flagMarkedAsPure);
- define_builtin_func("__throw", impure_un_op, compile_throw,
+ TypePtr Unit = TypeDataVoid::create();
+ TypePtr Int = TypeDataInt::create();
+ TypePtr Bool = TypeDataBool::create();
+ TypePtr Slice = TypeDataSlice::create();
+ TypePtr Builder = TypeDataBuilder::create();
+ TypePtr Tuple = TypeDataTuple::create();
+
+ std::vector<GenericsDeclaration::GenericsItem> itemsT;
+ itemsT.emplace_back("T");
+ TypePtr typeT = TypeDataGenericT::create("T");
+ const GenericsDeclaration* declGenericT = new GenericsDeclaration(std::move(itemsT));
+
+ std::vector ParamsInt1 = {Int};
+ std::vector ParamsInt2 = {Int, Int};
+ std::vector ParamsInt3 = {Int, Int, Int};
+ std::vector ParamsSliceInt = {Slice, Int};
+
+ // builtin operators
+ // they are internally stored as functions, because at IR level, there is no difference
+ // between calling `userAdd(a,b)` and `_+_(a,b)`
+ // since they are registered in a global symtable, technically, they can even be referenced from Tolk code,
+ // though it's a "hidden feature" and won't work well for overloads (`==` for int and bool, for example)
+
+ // unary operators
+ define_builtin_func("-_", ParamsInt1, Int, nullptr,
+ compile_unary_minus,
+ FunctionData::flagMarkedAsPure);
+ define_builtin_func("+_", ParamsInt1, Int, nullptr,
+ compile_unary_plus,
+ FunctionData::flagMarkedAsPure);
+ define_builtin_func("!_", ParamsInt1, Bool, nullptr,
+ std::bind(compile_logical_not, _1, _2, _3, true),
+ FunctionData::flagMarkedAsPure);
+ define_builtin_func("!b_", {Bool}, Bool, nullptr, // "overloaded" separate version for bool
+ std::bind(compile_logical_not, _1, _2, _3, false),
+ FunctionData::flagMarkedAsPure);
+ define_builtin_func("~_", ParamsInt1, Int, nullptr,
+ compile_bitwise_not,
+ FunctionData::flagMarkedAsPure);
+
+ // binary operators
+ define_builtin_func("_+_", ParamsInt2, Int, nullptr,
+ compile_add,
+ FunctionData::flagMarkedAsPure);
+ define_builtin_func("_-_", ParamsInt2, Int, nullptr,
+ compile_sub,
+ FunctionData::flagMarkedAsPure);
+ define_builtin_func("_*_", ParamsInt2, Int, nullptr,
+ compile_mul,
+ FunctionData::flagMarkedAsPure);
+ define_builtin_func("_/_", ParamsInt2, Int, nullptr,
+ std::bind(compile_div, _1, _2, _3, -1),
+ FunctionData::flagMarkedAsPure);
+ define_builtin_func("_~/_", ParamsInt2, Int, nullptr,
+ std::bind(compile_div, _1, _2, _3, 0),
+ FunctionData::flagMarkedAsPure);
+ define_builtin_func("_^/_", ParamsInt2, Int, nullptr,
+ std::bind(compile_div, _1, _2, _3, 1),
+ FunctionData::flagMarkedAsPure);
+ define_builtin_func("_%_", ParamsInt2, Int, nullptr,
+ std::bind(compile_mod, _1, _2, _3, -1),
+ FunctionData::flagMarkedAsPure);
+ define_builtin_func("_<<_", ParamsInt2, Int, nullptr,
+ compile_lshift,
+ FunctionData::flagMarkedAsPure);
+ define_builtin_func("_>>_", ParamsInt2, Int, nullptr,
+ std::bind(compile_rshift, _1, _2, _3, -1),
+ FunctionData::flagMarkedAsPure);
+ define_builtin_func("_~>>_", ParamsInt2, Int, nullptr,
+ std::bind(compile_rshift, _1, _2, _3, 0),
+ FunctionData::flagMarkedAsPure);
+ define_builtin_func("_^>>_", ParamsInt2, Int, nullptr,
+ std::bind(compile_rshift, _1, _2, _3, 1),
+ FunctionData::flagMarkedAsPure);
+ define_builtin_func("_&_", ParamsInt2, Int, nullptr, // also works for bool
+ compile_bitwise_and,
+ FunctionData::flagMarkedAsPure);
+ define_builtin_func("_|_", ParamsInt2, Int, nullptr, // also works for bool
+ compile_bitwise_or,
+ FunctionData::flagMarkedAsPure);
+ define_builtin_func("_^_", ParamsInt2, Int, nullptr, // also works for bool
+ compile_bitwise_xor,
+ FunctionData::flagMarkedAsPure);
+ define_builtin_func("_==_", ParamsInt2, Int, nullptr, // also works for bool
+ std::bind(compile_cmp_int, _1, _2, 2),
+ FunctionData::flagMarkedAsPure);
+ define_builtin_func("_!=_", ParamsInt2, Int, nullptr, // also works for bool
+ std::bind(compile_cmp_int, _1, _2, 5),
+ FunctionData::flagMarkedAsPure);
+ define_builtin_func("_<_", ParamsInt2, Int, nullptr,
+ std::bind(compile_cmp_int, _1, _2, 4),
+ FunctionData::flagMarkedAsPure);
+ define_builtin_func("_>_", ParamsInt2, Int, nullptr,
+ std::bind(compile_cmp_int, _1, _2, 1),
+ FunctionData::flagMarkedAsPure);
+ define_builtin_func("_<=_", ParamsInt2, Int, nullptr,
+ std::bind(compile_cmp_int, _1, _2, 6),
+ FunctionData::flagMarkedAsPure);
+ define_builtin_func("_>=_", ParamsInt2, Int, nullptr,
+ std::bind(compile_cmp_int, _1, _2, 3),
+ FunctionData::flagMarkedAsPure);
+ define_builtin_func("_<=>_", ParamsInt2, Int, nullptr,
+ std::bind(compile_cmp_int, _1, _2, 7),
+ FunctionData::flagMarkedAsPure);
+
+ // special function used for internal compilation of some lexical constructs
+ // for example, `throw 123;` is actually calling `__throw(123)`
+ define_builtin_func("__true", {}, Bool, nullptr, /* AsmOp::Const("TRUE") */
+ std::bind(compile_bool_const, _1, _2, true),
+ FunctionData::flagMarkedAsPure);
+ define_builtin_func("__false", {}, Bool, nullptr, /* AsmOp::Const("FALSE") */
+ std::bind(compile_bool_const, _1, _2, false),
+ FunctionData::flagMarkedAsPure);
+ define_builtin_func("__null", {}, typeT, declGenericT,
+ AsmOp::Const("PUSHNULL"),
+ FunctionData::flagMarkedAsPure);
+ define_builtin_func("__isNull", {typeT}, Bool, declGenericT,
+ compile_is_null,
+ FunctionData::flagMarkedAsPure);
+ define_builtin_func("__throw", ParamsInt1, Unit, nullptr,
+ compile_throw,
0);
- define_builtin_func("__throw_arg", throw_arg_op, compile_throw_arg,
+ define_builtin_func("__throw_arg", {typeT, Int}, Unit, declGenericT,
+ compile_throw_arg,
0);
- define_builtin_func("__throw_if_unless", TypeExpr::new_map(Int3, Unit), compile_throw_if_unless,
+ define_builtin_func("__throw_if_unless", ParamsInt3, Unit, nullptr,
+ compile_throw_if_unless,
0);
- define_builtin_func("loadInt", fetch_int_op_mutate, std::bind(compile_fetch_int, _1, _2, true, true),
- SymValFunc::flagMarkedAsPure | SymValFunc::flagHasMutateParams | SymValFunc::flagAcceptsSelf, {}, {1, 0});
- define_builtin_func("loadUint", fetch_int_op_mutate, std::bind(compile_fetch_int, _1, _2, true, false),
- SymValFunc::flagMarkedAsPure | SymValFunc::flagHasMutateParams | SymValFunc::flagAcceptsSelf, {}, {1, 0});
- define_builtin_func("loadBits", fetch_slice_op_mutate, std::bind(compile_fetch_slice, _1, _2, true),
- SymValFunc::flagMarkedAsPure | SymValFunc::flagHasMutateParams | SymValFunc::flagAcceptsSelf, {}, {1, 0});
- define_builtin_func("preloadInt", prefetch_int_op, std::bind(compile_fetch_int, _1, _2, false, true),
- SymValFunc::flagMarkedAsPure | SymValFunc::flagAcceptsSelf);
- define_builtin_func("preloadUint", prefetch_int_op, std::bind(compile_fetch_int, _1, _2, false, false),
- SymValFunc::flagMarkedAsPure | SymValFunc::flagAcceptsSelf);
- define_builtin_func("preloadBits", prefetch_slice_op, std::bind(compile_fetch_slice, _1, _2, false),
- SymValFunc::flagMarkedAsPure | SymValFunc::flagAcceptsSelf);
- define_builtin_func("storeInt", store_int_mutate, std::bind(compile_store_int, _1, _2, true),
- SymValFunc::flagMarkedAsPure | SymValFunc::flagHasMutateParams | SymValFunc::flagAcceptsSelf | SymValFunc::flagReturnsSelf, {1, 0, 2}, {});
- define_builtin_func("storeUint", store_int_mutate, std::bind(compile_store_int, _1, _2, false),
- SymValFunc::flagMarkedAsPure | SymValFunc::flagHasMutateParams | SymValFunc::flagAcceptsSelf | SymValFunc::flagReturnsSelf, {1, 0, 2}, {});
- define_builtin_func("tupleAt", TypeExpr::new_forall({X}, TypeExpr::new_map(TupleInt, X)), compile_tuple_at,
- SymValFunc::flagMarkedAsPure | SymValFunc::flagAcceptsSelf);
- define_builtin_func("debugPrint", TypeExpr::new_forall({X}, TypeExpr::new_map(X, Unit)),
+
+ // functions from stdlib marked as `builtin`, implemented at compiler level for optimizations
+ // (for example, `loadInt(1)` is `1 LDI`, but `loadInt(n)` for non-constant requires it be on a stack and `LDIX`)
+ define_builtin_func("mulDivFloor", ParamsInt3, Int, nullptr,
+ std::bind(compile_muldiv, _1, _2, _3, -1),
+ FunctionData::flagMarkedAsPure);
+ define_builtin_func("mulDivRound", ParamsInt3, Int, nullptr,
+ std::bind(compile_muldiv, _1, _2, _3, 0),
+ FunctionData::flagMarkedAsPure);
+ define_builtin_func("mulDivCeil", ParamsInt3, Int, nullptr,
+ std::bind(compile_muldiv, _1, _2, _3, 1),
+ FunctionData::flagMarkedAsPure);
+ define_builtin_func("mulDivMod", ParamsInt3, TypeDataTensor::create({Int, Int}), nullptr,
+ AsmOp::Custom("MULDIVMOD", 3, 2),
+ FunctionData::flagMarkedAsPure);
+ define_builtin_func("loadInt", ParamsSliceInt, Int, nullptr,
+ std::bind(compile_fetch_int, _1, _2, true, true),
+ FunctionData::flagMarkedAsPure | FunctionData::flagHasMutateParams | FunctionData::flagAcceptsSelf,
+ {}, {1, 0});
+ define_builtin_func("loadUint", ParamsSliceInt, Int, nullptr,
+ std::bind(compile_fetch_int, _1, _2, true, false),
+ FunctionData::flagMarkedAsPure | FunctionData::flagHasMutateParams | FunctionData::flagAcceptsSelf,
+ {}, {1, 0});
+ define_builtin_func("loadBits", ParamsSliceInt, Slice, nullptr,
+ std::bind(compile_fetch_slice, _1, _2, true),
+ FunctionData::flagMarkedAsPure | FunctionData::flagHasMutateParams | FunctionData::flagAcceptsSelf,
+ {}, {1, 0});
+ define_builtin_func("preloadInt", ParamsSliceInt, Int, nullptr,
+ std::bind(compile_fetch_int, _1, _2, false, true),
+ FunctionData::flagMarkedAsPure | FunctionData::flagAcceptsSelf);
+ define_builtin_func("preloadUint", ParamsSliceInt, Int, nullptr,
+ std::bind(compile_fetch_int, _1, _2, false, false),
+ FunctionData::flagMarkedAsPure | FunctionData::flagAcceptsSelf);
+ define_builtin_func("preloadBits", ParamsSliceInt, Slice, nullptr,
+ std::bind(compile_fetch_slice, _1, _2, false),
+ FunctionData::flagMarkedAsPure | FunctionData::flagAcceptsSelf);
+ define_builtin_func("storeInt", {Builder, Int, Int}, Unit, nullptr,
+ std::bind(compile_store_int, _1, _2, true),
+ FunctionData::flagMarkedAsPure | FunctionData::flagHasMutateParams | FunctionData::flagAcceptsSelf | FunctionData::flagReturnsSelf,
+ {1, 0, 2}, {});
+ define_builtin_func("storeUint", {Builder, Int, Int}, Unit, nullptr,
+ std::bind(compile_store_int, _1, _2, false),
+ FunctionData::flagMarkedAsPure | FunctionData::flagHasMutateParams | FunctionData::flagAcceptsSelf | FunctionData::flagReturnsSelf,
+ {1, 0, 2}, {});
+ define_builtin_func("tupleAt", {Tuple, Int}, typeT, declGenericT,
+ compile_tuple_at,
+ FunctionData::flagMarkedAsPure | FunctionData::flagAcceptsSelf);
+ define_builtin_func("debugPrint", {typeT}, Unit, declGenericT,
AsmOp::Custom("s0 DUMP DROP", 1, 1),
0);
- define_builtin_func("debugPrintString", TypeExpr::new_forall({X}, TypeExpr::new_map(X, Unit)),
+ define_builtin_func("debugPrintString", {typeT}, Unit, declGenericT,
AsmOp::Custom("STRDUMP DROP", 1, 1),
0);
- define_builtin_func("debugDumpStack", TypeExpr::new_map(Unit, Unit),
+ define_builtin_func("debugDumpStack", {}, Unit, nullptr,
AsmOp::Custom("DUMPSTK", 0, 0),
0);
}
diff --git a/tolk/codegen.cpp b/tolk/codegen.cpp
index 9a90a3ed9..3830f7ae5 100644
--- a/tolk/codegen.cpp
+++ b/tolk/codegen.cpp
@@ -16,6 +16,7 @@
*/
#include "tolk.h"
#include "compiler-state.h"
+#include "type-system.h"
namespace tolk {
@@ -314,7 +315,7 @@ bool Op::generate_code_step(Stack& stack) {
return true;
}
case _GlobVar:
- if (dynamic_cast<const SymValGlobVar*>(fun_ref->value)) {
+ if (g_sym) {
bool used = false;
for (auto i : left) {
auto p = next->var_info[i];
@@ -325,8 +326,7 @@ bool Op::generate_code_step(Stack& stack) {
if (!used || disabled()) {
return true;
}
- std::string name = G.symbols.get_name(fun_ref->sym_idx);
- stack.o << AsmOp::Custom(name + " GETGLOB", 0, 1);
+ stack.o << AsmOp::Custom(g_sym->name + " GETGLOB", 0, 1);
if (left.size() != 1) {
tolk_assert(left.size() <= 15);
stack.o << AsmOp::UnTuple((int)left.size());
@@ -343,25 +343,28 @@ bool Op::generate_code_step(Stack& stack) {
}
stack.o << "CONT:<{";
stack.o.indent();
- auto func = dynamic_cast<SymValAsmFunc*>(fun_ref->value);
- if (func) {
+ if (f_sym->is_asm_function() || f_sym->is_builtin_function()) {
// TODO: create and compile a true lambda instead of this (so that arg_order and ret_order would work correctly)
std::vector<VarDescr> args0, res;
- TypeExpr::remove_indirect(func->sym_type);
- tolk_assert(func->get_type()->is_map());
- auto wr = func->get_type()->args.at(0)->get_width();
- auto wl = func->get_type()->args.at(1)->get_width();
- tolk_assert(wl >= 0 && wr >= 0);
- for (int i = 0; i < wl; i++) {
+ int w_arg = 0;
+ for (const LocalVarData& param : f_sym->parameters) {
+ w_arg += param.declared_type->calc_width_on_stack();
+ }
+ int w_ret = f_sym->inferred_return_type->calc_width_on_stack();
+ tolk_assert(w_ret >= 0 && w_arg >= 0);
+ for (int i = 0; i < w_ret; i++) {
res.emplace_back(0);
}
- for (int i = 0; i < wr; i++) {
+ for (int i = 0; i < w_arg; i++) {
args0.emplace_back(0);
}
- func->compile(stack.o, res, args0, where); // compile res := f (args0)
+ if (f_sym->is_asm_function()) {
+ std::get<FunctionBodyAsm*>(f_sym->body)->compile(stack.o); // compile res := f (args0)
+ } else {
+ std::get<FunctionBodyBuiltin*>(f_sym->body)->compile(stack.o, res, args0, where); // compile res := f (args0)
+ }
} else {
- std::string name = G.symbols.get_name(fun_ref->sym_idx);
- stack.o << AsmOp::Custom(name + " CALLDICT", (int)right.size(), (int)left.size());
+ stack.o << AsmOp::Custom(f_sym->name + " CALLDICT", (int)right.size(), (int)left.size());
}
stack.o.undent();
stack.o << "}>";
@@ -438,10 +441,9 @@ bool Op::generate_code_step(Stack& stack) {
if (disabled()) {
return true;
}
- // fun_ref can be nullptr for Op::_CallInd (invoke a variable, not a function)
- SymValFunc* func = (fun_ref ? dynamic_cast<SymValFunc*>(fun_ref->value) : nullptr);
- auto arg_order = (func ? func->get_arg_order() : nullptr);
- auto ret_order = (func ? func->get_ret_order() : nullptr);
+ // f_sym can be nullptr for Op::_CallInd (invoke a variable, not a function)
+ const std::vector<int>* arg_order = f_sym ? f_sym->get_arg_order() : nullptr;
+ const std::vector<int>* ret_order = f_sym ? f_sym->get_ret_order() : nullptr;
tolk_assert(!arg_order || arg_order->size() == right.size());
tolk_assert(!ret_order || ret_order->size() == left.size());
std::vector<var_idx_t> right1;
@@ -455,14 +457,12 @@ bool Op::generate_code_step(Stack& stack) {
right1.push_back(arg.idx);
}
}
- } else if (arg_order) {
- for (int i = 0; i < (int)right.size(); i++) {
- right1.push_back(right.at(arg_order->at(i)));
- }
} else {
+ tolk_assert(!arg_order);
right1 = right;
}
std::vector<bool> last;
+ last.reserve(right1.size());
for (var_idx_t x : right1) {
last.push_back(var_info[x] && var_info[x]->is_last());
}
@@ -488,23 +488,25 @@ bool Op::generate_code_step(Stack& stack) {
};
if (cl == _CallInd) {
exec_callxargs((int)right.size() - 1, (int)left.size());
- } else if (auto asm_fv = dynamic_cast<const SymValAsmFunc*>(fun_ref->value)) {
+ } else if (!f_sym->is_code_function()) {
std::vector<VarDescr> res;
res.reserve(left.size());
for (var_idx_t i : left) {
res.emplace_back(i);
}
- asm_fv->compile(stack.o, res, args, where); // compile res := f (args)
+ if (f_sym->is_asm_function()) {
+ std::get<FunctionBodyAsm*>(f_sym->body)->compile(stack.o); // compile res := f (args)
+ } else {
+ std::get<FunctionBodyBuiltin*>(f_sym->body)->compile(stack.o, res, args, where); // compile res := f (args)
+ }
} else {
- auto fv = dynamic_cast<const SymValCodeFunc*>(fun_ref->value);
- std::string name = G.symbols.get_name(fun_ref->sym_idx);
- if (fv->is_inline() || fv->is_inline_ref()) {
- stack.o << AsmOp::Custom(name + " INLINECALLDICT", (int)right.size(), (int)left.size());
- } else if (fv->code && fv->code->require_callxargs) {
- stack.o << AsmOp::Custom(name + (" PREPAREDICT"), 0, 2);
+ if (f_sym->is_inline() || f_sym->is_inline_ref()) {
+ stack.o << AsmOp::Custom(f_sym->name + " INLINECALLDICT", (int)right.size(), (int)left.size());
+ } else if (f_sym->is_code_function() && std::get<FunctionBodyCode*>(f_sym->body)->code->require_callxargs) {
+ stack.o << AsmOp::Custom(f_sym->name + (" PREPAREDICT"), 0, 2);
exec_callxargs((int)right.size() + 1, (int)left.size());
} else {
- stack.o << AsmOp::Custom(name + " CALLDICT", (int)right.size(), (int)left.size());
+ stack.o << AsmOp::Custom(f_sym->name + " CALLDICT", (int)right.size(), (int)left.size());
}
}
stack.s.resize(k);
@@ -515,7 +517,7 @@ bool Op::generate_code_step(Stack& stack) {
return true;
}
case _SetGlob: {
- tolk_assert(fun_ref && dynamic_cast<const SymValGlobVar*>(fun_ref->value));
+ tolk_assert(g_sym);
std::vector<bool> last;
for (var_idx_t x : right) {
last.push_back(var_info[x] && var_info[x]->is_last());
@@ -534,8 +536,7 @@ bool Op::generate_code_step(Stack& stack) {
stack.o << AsmOp::Tuple((int)right.size());
}
if (!right.empty()) {
- std::string name = G.symbols.get_name(fun_ref->sym_idx);
- stack.o << AsmOp::Custom(name + " SETGLOB", 1, 0);
+ stack.o << AsmOp::Custom(g_sym->name + " SETGLOB", 1, 0);
}
stack.s.resize(k);
return true;
@@ -826,6 +827,8 @@ bool Op::generate_code_step(Stack& stack) {
catch_stack.push_new_var(left[1]);
stack.rearrange_top(catch_vars, catch_last);
stack.opt_show();
+ stack.o << "c1 PUSH";
+ stack.o << "c3 PUSH";
stack.o << "c4 PUSH";
stack.o << "c5 PUSH";
stack.o << "c7 PUSH";
@@ -842,6 +845,8 @@ bool Op::generate_code_step(Stack& stack) {
stack.o << "c7 SETCONT";
stack.o << "c5 SETCONT";
stack.o << "c4 SETCONT";
+ stack.o << "c3 SETCONT";
+ stack.o << "c1 SETCONT";
for (size_t begin = catch_vars.size(), end = begin; end > 0; end = begin) {
begin = end >= block_size ? end - block_size : 0;
stack.o << std::to_string(end - begin) + " PUSHINT";
diff --git a/tolk/compiler-state.cpp b/tolk/compiler-state.cpp
index fb70022fa..66fad844f 100644
--- a/tolk/compiler-state.cpp
+++ b/tolk/compiler-state.cpp
@@ -27,6 +27,19 @@ void ExperimentalOption::mark_deprecated(const char* deprecated_from_v, const ch
this->deprecated_reason = deprecated_reason;
}
+std::string_view PersistentHeapAllocator::copy_string_to_persistent_memory(std::string_view str_in_tmp_memory) {
+ size_t len = str_in_tmp_memory.size();
+ char* allocated = new char[len];
+ memcpy(allocated, str_in_tmp_memory.data(), str_in_tmp_memory.size());
+ auto new_chunk = std::make_unique<ChunkInHeap>(allocated, std::move(head));
+ head = std::move(new_chunk);
+ return {head->allocated, len};
+}
+
+void PersistentHeapAllocator::clear() {
+ head = nullptr;
+}
+
void CompilerSettings::enable_experimental_option(std::string_view name) {
ExperimentalOption* to_enable = nullptr;
@@ -53,4 +66,8 @@ void CompilerSettings::parse_experimental_options_cmd_arg(const std::string& cmd
}
}
+const std::vector<const FunctionData*>& get_all_not_builtin_functions() {
+ return G.all_functions;
+}
+
} // namespace tolk
diff --git a/tolk/compiler-state.h b/tolk/compiler-state.h
index aec1945e2..d33eec81d 100644
--- a/tolk/compiler-state.h
+++ b/tolk/compiler-state.h
@@ -19,6 +19,7 @@
#include "src-file.h"
#include "symtable.h"
#include "td/utils/Status.h"
+#include <functional>
#include <set>
#include <string>
@@ -64,6 +65,26 @@ struct CompilerSettings {
void parse_experimental_options_cmd_arg(const std::string& cmd_arg);
};
+// AST nodes contain std::string_view referencing to contents of .tolk files (kept in memory after reading).
+// It's more than enough, except a situation when we create new AST nodes inside the compiler
+// and want some "persistent place" for std::string_view to point to.
+// This class copies strings to heap, so that they remain valid after closing scope.
+class PersistentHeapAllocator {
+ struct ChunkInHeap {
+ const char* allocated;
+ std::unique_ptr<ChunkInHeap> next;
+
+ ChunkInHeap(const char* allocated, std::unique_ptr<ChunkInHeap>&& next)
+ : allocated(allocated), next(std::move(next)) {}
+ };
+
+ std::unique_ptr<ChunkInHeap> head = nullptr;
+
+public:
+ std::string_view copy_string_to_persistent_memory(std::string_view str_in_tmp_memory);
+ void clear();
+};
+
// CompilerState contains a mutable state that is changed while the compilation is going on.
// It's a "global state" of all compilation.
// Historically, in FunC, this global state was spread along many global C++ variables.
@@ -71,14 +92,13 @@ struct CompilerSettings {
struct CompilerState {
CompilerSettings settings;
- SymTable symbols;
- int scope_level = 0;
- SymDef* sym_def[SymTable::SIZE_PRIME + 1]{};
- SymDef* global_sym_def[SymTable::SIZE_PRIME + 1]{};
- std::vector<std::pair<int, SymDef>> symbol_stack;
- std::vector<SrcLocation> scope_opened_at;
+ GlobalSymbolTable symtable;
+ PersistentHeapAllocator persistent_mem;
- std::vector<SymDef*> all_code_functions, all_global_vars, all_get_methods, all_constants;
+ std::vector<const FunctionData*> all_functions; // all user-defined (not built-in) functions, with generic instantiations
+ std::vector<const FunctionData*> all_get_methods;
+ std::vector<const GlobalVarData*> all_global_vars;
+ std::vector<const GlobalConstData*> all_constants;
AllRegisteredSrcFiles all_src_files;
bool is_verbosity(int gt_eq) const { return settings.verbosity >= gt_eq; }
diff --git a/tolk/constant-evaluator.cpp b/tolk/constant-evaluator.cpp
new file mode 100644
index 000000000..9ad273812
--- /dev/null
+++ b/tolk/constant-evaluator.cpp
@@ -0,0 +1,317 @@
+/*
+ This file is part of TON Blockchain Library.
+
+ TON Blockchain Library is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Lesser General Public License as published by
+ the Free Software Foundation, either version 2 of the License, or
+ (at your option) any later version.
+
+ TON Blockchain Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public License
+ along with TON Blockchain Library. If not, see <http://www.gnu.org/licenses/>.
+*/
+#include "constant-evaluator.h"
+#include "ast.h"
+#include "tolk.h"
+#include "openssl/digest.hpp"
+#include "crypto/common/util.h"
+#include "td/utils/crypto.h"
+#include "ton/ton-types.h"
+
+namespace tolk {
+
+// parse address like "EQCRDM9h4k3UJdOePPuyX40mCgA4vxge5Dc5vjBR8djbEKC5"
+// based on unpack_std_smc_addr() from block.cpp
+// (which is not included to avoid linking with ton_crypto)
+static bool parse_friendly_address(const char packed[48], ton::WorkchainId& workchain, ton::StdSmcAddress& addr) {
+ unsigned char buffer[36];
+ if (!td::buff_base64_decode(td::MutableSlice{buffer, 36}, td::Slice{packed, 48}, true)) {
+ return false;
+ }
+ td::uint16 crc = td::crc16(td::Slice{buffer, 34});
+ if (buffer[34] != (crc >> 8) || buffer[35] != (crc & 0xff) || (buffer[0] & 0x3f) != 0x11) {
+ return false;
+ }
+ workchain = static_cast<td::int8>(buffer[1]);
+ std::memcpy(addr.data(), buffer + 2, 32);
+ return true;
+}
+
+// parse address like "0:527964d55cfa6eb731f4bfc07e9d025098097ef8505519e853986279bd8400d8"
+// based on StdAddress::parse_addr() from block.cpp
+// (which is not included to avoid linking with ton_crypto)
+static bool parse_raw_address(const std::string& acc_string, int& workchain, ton::StdSmcAddress& addr) {
+ size_t pos = acc_string.find(':');
+ if (pos != std::string::npos) {
+ td::Result<int> r_wc = td::to_integer_safe<ton::WorkchainId>(acc_string.substr(0, pos));
+ if (r_wc.is_error()) {
+ return false;
+ }
+ workchain = r_wc.move_as_ok();
+ pos++;
+ } else {
+ pos = 0;
+ }
+ if (acc_string.size() != pos + 64) {
+ return false;
+ }
+
+ for (int i = 0; i < 64; ++i) { // loop through each hex digit
+ char c = acc_string[pos + i];
+ int x;
+ if (c >= '0' && c <= '9') {
+ x = c - '0';
+ } else if (c >= 'a' && c <= 'z') {
+ x = c - 'a' + 10;
+ } else if (c >= 'A' && c <= 'Z') {
+ x = c - 'A' + 10;
+ } else {
+ return false;
+ }
+
+ if ((i & 1) == 0) {
+ addr.data()[i >> 1] = static_cast<unsigned char>((addr.data()[i >> 1] & 0x0F) | (x << 4));
+ } else {
+ addr.data()[i >> 1] = static_cast<unsigned char>((addr.data()[i >> 1] & 0xF0) | x);
+ }
+ }
+ return true;
+}
+
+
+static std::string parse_vertex_string_const_as_slice(V<ast_string_const> v) {
+ std::string str = static_cast<std::string>(v->str_val);
+ switch (v->modifier) {
+ case 0: {
+ return td::hex_encode(str);
+ }
+ case 's': {
+ unsigned char buff[128];
+ long bits = td::bitstring::parse_bitstring_hex_literal(buff, sizeof(buff), str.data(), str.data() + str.size());
+ if (bits < 0) {
+ v->error("invalid hex bitstring constant '" + str + "'");
+ }
+ return str;
+ }
+ case 'a': { // MsgAddress
+ ton::WorkchainId workchain;
+ ton::StdSmcAddress addr;
+ bool correct = (str.size() == 48 && parse_friendly_address(str.data(), workchain, addr)) ||
+ (str.size() != 48 && parse_raw_address(str, workchain, addr));
+ if (!correct) {
+ v->error("invalid standard address '" + str + "'");
+ }
+ if (workchain < -128 || workchain >= 128) {
+ v->error("anycast addresses not supported");
+ }
+
+ unsigned char data[3 + 8 + 256]; // addr_std$10 anycast:(Maybe Anycast) workchain_id:int8 address:bits256 = MsgAddressInt;
+ td::bitstring::bits_store_long_top(data, 0, static_cast<uint64_t>(4) << (64 - 3), 3);
+ td::bitstring::bits_store_long_top(data, 3, static_cast<uint64_t>(workchain) << (64 - 8), 8);
+ td::bitstring::bits_memcpy(data, 3 + 8, addr.bits().ptr, 0, ton::StdSmcAddress::size());
+ return td::BitSlice{data, sizeof(data)}.to_hex();
+ }
+ default:
+ tolk_assert(false);
+ }
+}
+
+static td::RefInt256 parse_vertex_string_const_as_int(V<ast_string_const> v) {
+ std::string str = static_cast<std::string>(v->str_val);
+ switch (v->modifier) {
+ case 'u': {
+ td::RefInt256 intval = td::hex_string_to_int256(td::hex_encode(str));
+ if (str.empty()) {
+ v->error("empty integer ascii-constant");
+ }
+ if (intval.is_null()) {
+ v->error("too long integer ascii-constant");
+ }
+ return intval;
+ }
+ case 'h':
+ case 'H': {
+ unsigned char hash[32];
+ digest::hash_str<digest::SHA256>(hash, str.data(), str.size());
+ return td::bits_to_refint(hash, (v->modifier == 'h') ? 32 : 256, false);
+ }
+ case 'c': {
+ return td::make_refint(td::crc32(td::Slice{str}));
+ }
+ default:
+ tolk_assert(false);
+ }
+}
+
+
+struct ConstantEvaluator {
+ static bool is_overflow(const td::RefInt256& intval) {
+ return intval.is_null() || !intval->signed_fits_bits(257);
+ }
+
+ static ConstantValue handle_unary_operator(V<ast_unary_operator> v, const ConstantValue& rhs) {
+ if (!rhs.is_int()) {
+ v->error("invalid operator, expecting integer");
+ }
+ td::RefInt256 intval = std::get<td::RefInt256>(rhs.value);
+
+ switch (v->tok) {
+ case tok_minus:
+ intval = -intval;
+ break;
+ case tok_plus:
+ break;
+ case tok_bitwise_not:
+ intval = ~intval;
+ break;
+ case tok_logical_not:
+ intval = td::make_refint(intval == 0 ? -1 : 0);
+ break;
+ default:
+ v->error("not a constant expression");
+ }
+
+ if (is_overflow(intval)) {
+ v->error("integer overflow");
+ }
+ return ConstantValue::from_int(std::move(intval));
+ }
+
+ static ConstantValue handle_binary_operator(V<ast_binary_operator> v, const ConstantValue& lhs, const ConstantValue& rhs) {
+ if (!lhs.is_int() || !rhs.is_int()) {
+ v->error("invalid operator, expecting integer");
+ }
+ td::RefInt256 lhs_intval = std::get<td::RefInt256>(lhs.value);
+ td::RefInt256 rhs_intval = std::get<td::RefInt256>(rhs.value);
+ td::RefInt256 intval;
+
+ switch (v->tok) {
+ case tok_minus:
+ intval = lhs_intval - rhs_intval;
+ break;
+ case tok_plus:
+ intval = lhs_intval + rhs_intval;
+ break;
+ case tok_mul:
+ intval = lhs_intval * rhs_intval;
+ break;
+ case tok_div:
+ intval = lhs_intval / rhs_intval;
+ break;
+ case tok_mod:
+ intval = lhs_intval % rhs_intval;
+ break;
+ case tok_lshift:
+ intval = lhs_intval << static_cast<int>(rhs_intval->to_long());
+ break;
+ case tok_rshift:
+ intval = lhs_intval >> static_cast<int>(rhs_intval->to_long());
+ break;
+ case tok_bitwise_and:
+ intval = lhs_intval & rhs_intval;
+ break;
+ case tok_bitwise_or:
+ intval = lhs_intval | rhs_intval;
+ break;
+ case tok_bitwise_xor:
+ intval = lhs_intval ^ rhs_intval;
+ break;
+ case tok_eq:
+ intval = td::make_refint(lhs_intval == rhs_intval ? -1 : 0);
+ break;
+ case tok_lt:
+ intval = td::make_refint(lhs_intval < rhs_intval ? -1 : 0);
+ break;
+ case tok_gt:
+ intval = td::make_refint(lhs_intval > rhs_intval ? -1 : 0);
+ break;
+ case tok_leq:
+ intval = td::make_refint(lhs_intval <= rhs_intval ? -1 : 0);
+ break;
+ case tok_geq:
+ intval = td::make_refint(lhs_intval >= rhs_intval ? -1 : 0);
+ break;
+ case tok_neq:
+ intval = td::make_refint(lhs_intval != rhs_intval ? -1 : 0);
+ break;
+ default:
+ v->error("unsupported binary operator in constant expression");
+ }
+
+ if (is_overflow(intval)) {
+ v->error("integer overflow");
+ }
+ return ConstantValue::from_int(std::move(intval));
+ }
+
+ static ConstantValue handle_reference(V<ast_reference> v) {
+ // todo better handle "appears, directly or indirectly, in its own initializer"
+ std::string_view name = v->get_name();
+ const Symbol* sym = lookup_global_symbol(name);
+ if (!sym) {
+ v->error("undefined symbol `" + static_cast<std::string>(name) + "`");
+ }
+ const GlobalConstData* const_ref = sym->try_as<GlobalConstData>();
+ if (!const_ref) {
+ v->error("symbol `" + static_cast<std::string>(name) + "` is not a constant");
+ }
+ if (v->has_instantiationTs()) { // SOME_CONST<int>
+ v->error("constant is not a generic");
+ }
+ return {const_ref->value};
+ }
+
+ static ConstantValue visit(AnyExprV v) {
+ if (auto v_int = v->try_as<ast_int_const>()) {
+ return ConstantValue::from_int(v_int->intval);
+ }
+ if (auto v_bool = v->try_as<ast_bool_const>()) {
+ return ConstantValue::from_int(v_bool->bool_val ? -1 : 0);
+ }
+ if (auto v_unop = v->try_as<ast_unary_operator>()) {
+ return handle_unary_operator(v_unop, visit(v_unop->get_rhs()));
+ }
+ if (auto v_binop = v->try_as<ast_binary_operator>()) {
+ return handle_binary_operator(v_binop, visit(v_binop->get_lhs()), visit(v_binop->get_rhs()));
+ }
+ if (auto v_ref = v->try_as<ast_reference>()) {
+ return handle_reference(v_ref);
+ }
+ if (auto v_par = v->try_as<ast_parenthesized_expression>()) {
+ return visit(v_par->get_expr());
+ }
+ if (v->try_as<ast_string_const>()) {
+ return eval_const_init_value(v);
+ }
+ v->error("not a constant expression");
+ }
+
+ static ConstantValue eval_const_init_value(AnyExprV init_value) {
+ // it init_value is incorrect, an exception is thrown
+ return visit(init_value);
+ }
+};
+
+ConstantValue eval_const_init_value(AnyExprV init_value) {
+ // at first, handle most simple cases, not to launch heavy computation algorithm: just a number, just a string
+ // just `c = 1` or `c = 0xFF`
+ if (auto v_int = init_value->try_as<ast_int_const>()) {
+ return {v_int->intval};
+ }
+ // just `c = "strval"`, probably with modifier (address, etc.)
+ if (auto v_string = init_value->try_as<ast_string_const>()) {
+ if (v_string->is_bitslice()) {
+ return {parse_vertex_string_const_as_slice(v_string)};
+ } else {
+ return {parse_vertex_string_const_as_int(v_string)};
+ }
+ }
+ // something more complex, like `c = anotherC` or `c = 1 << 8`
+ return ConstantEvaluator::eval_const_init_value(init_value);
+}
+
+} // namespace tolk
diff --git a/tolk/constant-evaluator.h b/tolk/constant-evaluator.h
new file mode 100644
index 000000000..0f99867d8
--- /dev/null
+++ b/tolk/constant-evaluator.h
@@ -0,0 +1,45 @@
+/*
+ This file is part of TON Blockchain Library.
+
+ TON Blockchain Library is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Lesser General Public License as published by
+ the Free Software Foundation, either version 2 of the License, or
+ (at your option) any later version.
+
+ TON Blockchain Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public License
+ along with TON Blockchain Library. If not, see <http://www.gnu.org/licenses/>.
+*/
+#pragma once
+
+#include "fwd-declarations.h"
+#include "crypto/common/refint.h"
+#include <variant>
+
+namespace tolk {
+
+struct ConstantValue {
+ std::variant<td::RefInt256, std::string> value;
+
+ bool is_int() const { return std::holds_alternative<td::RefInt256>(value); }
+ bool is_slice() const { return std::holds_alternative<std::string>(value); }
+
+ td::RefInt256 as_int() const { return std::get<td::RefInt256>(value); }
+ const std::string& as_slice() const { return std::get<std::string>(value); }
+
+ static ConstantValue from_int(int value) {
+ return {td::make_refint(value)};
+ }
+
+ static ConstantValue from_int(td::RefInt256 value) {
+ return {std::move(value)};
+ }
+};
+
+ConstantValue eval_const_init_value(AnyExprV init_value);
+
+} // namespace tolk
diff --git a/tolk/fwd-declarations.h b/tolk/fwd-declarations.h
new file mode 100644
index 000000000..e3599f364
--- /dev/null
+++ b/tolk/fwd-declarations.h
@@ -0,0 +1,40 @@
+/*
+ This file is part of TON Blockchain Library.
+
+ TON Blockchain Library is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Lesser General Public License as published by
+ the Free Software Foundation, either version 2 of the License, or
+ (at your option) any later version.
+
+ TON Blockchain Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public License
+ along with TON Blockchain Library. If not, see <http://www.gnu.org/licenses/>.
+*/
+#pragma once
+
+namespace tolk {
+
+struct ASTNodeBase;
+struct ASTNodeExpressionBase;
+struct ASTNodeStatementBase;
+
+using AnyV = const ASTNodeBase*;
+using AnyExprV = const ASTNodeExpressionBase*;
+using AnyStatementV = const ASTNodeStatementBase*;
+
+struct Symbol;
+struct LocalVarData;
+struct FunctionData;
+struct GlobalVarData;
+struct GlobalConstData;
+
+class TypeData;
+using TypePtr = const TypeData*;
+
+struct SrcFile;
+
+} // namespace tolk
diff --git a/tolk/gen-abscode.cpp b/tolk/gen-abscode.cpp
deleted file mode 100644
index fb085ae9c..000000000
--- a/tolk/gen-abscode.cpp
+++ /dev/null
@@ -1,429 +0,0 @@
-/*
- This file is part of TON Blockchain Library.
-
- TON Blockchain Library is free software: you can redistribute it and/or modify
- it under the terms of the GNU Lesser General Public License as published by
- the Free Software Foundation, either version 2 of the License, or
- (at your option) any later version.
-
- TON Blockchain Library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public License
- along with TON Blockchain Library. If not, see <http://www.gnu.org/licenses/>.
-*/
-#include "tolk.h"
-#include "compiler-state.h"
-
-using namespace std::literals::string_literals;
-
-namespace tolk {
-
-/*
- *
- * EXPRESSIONS
- *
- */
-
-Expr* Expr::copy() const {
- auto res = new Expr{*this};
- for (auto& arg : res->args) {
- arg = arg->copy();
- }
- return res;
-}
-
-Expr::Expr(ExprCls c, sym_idx_t name_idx, std::initializer_list<Expr*> _arglist) : cls(c), args(std::move(_arglist)) {
- sym = lookup_symbol(name_idx);
- if (!sym) {
- }
-}
-
-void Expr::deduce_type() {
- if (e_type) {
- return;
- }
- switch (cls) {
- case _Apply: {
- if (!sym) {
- return;
- }
- SymValFunc* sym_val = dynamic_cast<SymValFunc*>(sym->value);
- if (!sym_val || !sym_val->get_type()) {
- return;
- }
- std::vector<TypeExpr*> arg_types;
- arg_types.reserve(args.size());
- for (const Expr* arg : args) {
- arg_types.push_back(arg->e_type);
- }
- TypeExpr* fun_type = TypeExpr::new_map(TypeExpr::new_tensor(arg_types), TypeExpr::new_hole());
- try {
- unify(fun_type, sym_val->sym_type);
- } catch (UnifyError& ue) {
- std::ostringstream os;
- os << "cannot apply function " << sym->name() << " : " << sym_val->get_type() << " to arguments of type "
- << fun_type->args[0] << ": " << ue;
- throw ParseError(here, os.str());
- }
- e_type = fun_type->args[1];
- TypeExpr::remove_indirect(e_type);
- return;
- }
- case _VarApply: {
- tolk_assert(args.size() == 2);
- TypeExpr* fun_type = TypeExpr::new_map(args[1]->e_type, TypeExpr::new_hole());
- try {
- unify(fun_type, args[0]->e_type);
- } catch (UnifyError& ue) {
- std::ostringstream os;
- os << "cannot apply expression of type " << args[0]->e_type << " to an expression of type " << args[1]->e_type
- << ": " << ue;
- throw ParseError(here, os.str());
- }
- e_type = fun_type->args[1];
- TypeExpr::remove_indirect(e_type);
- return;
- }
- case _GrabMutatedVars: {
- tolk_assert(args.size() == 2 && args[0]->cls == _Apply && sym);
- SymValFunc* called_f = dynamic_cast<SymValFunc*>(sym->value);
- tolk_assert(called_f->has_mutate_params());
- TypeExpr* sym_type = called_f->get_type();
- if (sym_type->constr == TypeExpr::te_ForAll) {
- TypeExpr::remove_forall(sym_type);
- }
- tolk_assert(sym_type->args[1]->constr == TypeExpr::te_Tensor);
- e_type = sym_type->args[1]->args[sym_type->args[1]->args.size() - 1];
- TypeExpr::remove_indirect(e_type);
- return;
- }
- case _ReturnSelf: {
- tolk_assert(args.size() == 2 && sym);
- Expr* this_arg = args[1];
- e_type = this_arg->e_type;
- TypeExpr::remove_indirect(e_type);
- return;
- }
- case _Letop: {
- tolk_assert(args.size() == 2);
- try {
- // std::cerr << "in assignment: " << args[0]->e_type << " from " << args[1]->e_type << std::endl;
- unify(args[0]->e_type, args[1]->e_type);
- } catch (UnifyError& ue) {
- std::ostringstream os;
- os << "cannot assign an expression of type " << args[1]->e_type << " to a variable or pattern of type "
- << args[0]->e_type << ": " << ue;
- throw ParseError(here, os.str());
- }
- e_type = args[0]->e_type;
- TypeExpr::remove_indirect(e_type);
- return;
- }
- case _CondExpr: {
- tolk_assert(args.size() == 3);
- auto flag_type = TypeExpr::new_atomic(TypeExpr::_Int);
- try {
- unify(args[0]->e_type, flag_type);
- } catch (UnifyError& ue) {
- std::ostringstream os;
- os << "condition in a conditional expression has non-integer type " << args[0]->e_type << ": " << ue;
- throw ParseError(here, os.str());
- }
- try {
- unify(args[1]->e_type, args[2]->e_type);
- } catch (UnifyError& ue) {
- std::ostringstream os;
- os << "the two variants in a conditional expression have different types " << args[1]->e_type << " and "
- << args[2]->e_type << " : " << ue;
- throw ParseError(here, os.str());
- }
- e_type = args[1]->e_type;
- TypeExpr::remove_indirect(e_type);
- return;
- }
- default:
- throw Fatal("unexpected cls=" + std::to_string(cls) + " in Expr::deduce_type()");
- }
-}
-
-void Expr::define_new_vars(CodeBlob& code) {
- switch (cls) {
- case _Tensor:
- case _MkTuple: {
- for (Expr* item : args) {
- item->define_new_vars(code);
- }
- break;
- }
- case _Var:
- if (val < 0) {
- val = code.create_var(e_type, sym->sym_idx, here);
- sym->value->idx = val;
- }
- break;
- case _Hole:
- if (val < 0) {
- val = code.create_tmp_var(e_type, here);
- }
- break;
- default:
- break;
- }
-}
-
-void Expr::predefine_vars() {
- switch (cls) {
- case _Tensor:
- case _MkTuple: {
- for (Expr* item : args) {
- item->predefine_vars();
- }
- break;
- }
- case _Var:
- if (!sym) {
- tolk_assert(val < 0 && here.is_defined());
- sym = define_symbol(~val, false, here);
- // std::cerr << "predefining variable " << symbols.get_name(~val) << std::endl;
- if (!sym) {
- throw ParseError{here, std::string{"redefined variable `"} + G.symbols.get_name(~val) + "`"};
- }
- sym->value = new SymValVariable(-1, e_type);
- if (is_immutable()) {
- dynamic_cast<SymValVariable*>(sym->value)->flags |= SymValVariable::flagImmutable;
- }
- }
- break;
- default:
- break;
- }
-}
-
-var_idx_t Expr::new_tmp(CodeBlob& code) const {
- return code.create_tmp_var(e_type, here);
-}
-
-void add_set_globs(CodeBlob& code, std::vector<std::pair<SymDef*, var_idx_t>>& globs, SrcLocation here) {
- for (const auto& p : globs) {
- auto& op = code.emplace_back(here, Op::_SetGlob, std::vector<var_idx_t>{}, std::vector<var_idx_t>{ p.second }, p.first);
- op.set_impure(code);
- }
-}
-
-std::vector<var_idx_t> pre_compile_let(CodeBlob& code, Expr* lhs, Expr* rhs, SrcLocation here) {
- if (lhs->is_mktuple()) {
- if (rhs->is_mktuple()) {
- return pre_compile_let(code, lhs->args.at(0), rhs->args.at(0), here);
- }
- auto right = rhs->pre_compile(code);
- TypeExpr::remove_indirect(rhs->e_type);
- auto unpacked_type = rhs->e_type->args.at(0);
- std::vector<var_idx_t> tmp{code.create_tmp_var(unpacked_type, rhs->here)};
- code.emplace_back(lhs->here, Op::_UnTuple, tmp, std::move(right));
- auto tvar = new Expr{Expr::_Var, lhs->here};
- tvar->set_val(tmp[0]);
- tvar->set_location(rhs->here);
- tvar->e_type = unpacked_type;
- pre_compile_let(code, lhs->args.at(0), tvar, here);
- return tmp;
- }
- auto right = rhs->pre_compile(code);
- std::vector<std::pair<SymDef*, var_idx_t>> globs;
- auto left = lhs->pre_compile(code, &globs);
- for (var_idx_t v : left) {
- code.on_var_modification(v, here);
- }
- code.emplace_back(here, Op::_Let, std::move(left), right);
- add_set_globs(code, globs, here);
- return right;
-}
-
-std::vector<var_idx_t> pre_compile_tensor(const std::vector<Expr *>& args, CodeBlob &code,
- std::vector<std::pair<SymDef*, var_idx_t>> *lval_globs) {
- const size_t n = args.size();
- if (n == 0) { // just `()`
- return {};
- }
- if (n == 1) { // just `(x)`: even if x is modified (e.g. `f(x=x+2)`), there are no next arguments
- return args[0]->pre_compile(code, lval_globs);
- }
- std::vector<std::vector<var_idx_t>> res_lists(n);
-
- struct ModifiedVar {
- size_t i, j;
- std::unique_ptr<Op>* cur_ops; // `LET tmp = v_ij` will be inserted before this
- };
- std::vector<ModifiedVar> modified_vars;
- for (size_t i = 0; i < n; ++i) {
- res_lists[i] = args[i]->pre_compile(code, lval_globs);
- for (size_t j = 0; j < res_lists[i].size(); ++j) {
- TmpVar& var = code.vars.at(res_lists[i][j]);
- if (!lval_globs && !var.is_unnamed()) {
- var.on_modification.push_back([&modified_vars, i, j, cur_ops = code.cur_ops, done = false](SrcLocation here) mutable {
- if (!done) {
- done = true;
- modified_vars.push_back({i, j, cur_ops});
- }
- });
- } else {
- var.on_modification.push_back([](SrcLocation) {
- });
- }
- }
- }
- for (const auto& list : res_lists) {
- for (var_idx_t v : list) {
- tolk_assert(!code.vars.at(v).on_modification.empty());
- code.vars.at(v).on_modification.pop_back();
- }
- }
- for (size_t idx = modified_vars.size(); idx--; ) {
- const ModifiedVar &m = modified_vars[idx];
- var_idx_t orig_v = res_lists[m.i][m.j];
- var_idx_t tmp_v = code.create_tmp_var(code.vars[orig_v].v_type, code.vars[orig_v].where);
- std::unique_ptr<Op> op = std::make_unique<Op>(code.vars[orig_v].where, Op::_Let);
- op->left = {tmp_v};
- op->right = {orig_v};
- op->next = std::move((*m.cur_ops));
- *m.cur_ops = std::move(op);
- res_lists[m.i][m.j] = tmp_v;
- }
- std::vector<var_idx_t> res;
- for (const auto& list : res_lists) {
- res.insert(res.end(), list.cbegin(), list.cend());
- }
- return res;
-}
-
-std::vector<var_idx_t> Expr::pre_compile(CodeBlob& code, std::vector<std::pair<SymDef*, var_idx_t>>* lval_globs) const {
- if (lval_globs && !(cls == _Tensor || cls == _Var || cls == _Hole || cls == _GlobVar)) {
- std::cerr << "lvalue expression constructor is " << cls << std::endl;
- throw Fatal{"cannot compile lvalue expression with unknown constructor"};
- }
- switch (cls) {
- case _Tensor: {
- return pre_compile_tensor(args, code, lval_globs);
- }
- case _Apply: {
- tolk_assert(sym);
- std::vector<var_idx_t> res = pre_compile_tensor(args, code, lval_globs);;
- auto rvect = new_tmp_vect(code);
- auto& op = code.emplace_back(here, Op::_Call, rvect, res, sym);
- if (flags & _IsImpure) {
- op.set_impure(code);
- }
- return rvect;
- }
- case _GrabMutatedVars: {
- SymValFunc* func_val = dynamic_cast<SymValFunc*>(sym->value);
- tolk_assert(func_val && func_val->has_mutate_params());
- tolk_assert(args.size() == 2 && args[0]->cls == _Apply && args[1]->cls == _Tensor);
- auto right = args[0]->pre_compile(code); // apply (returning function result and mutated)
- std::vector<std::pair<SymDef*, var_idx_t>> local_globs;
- if (!lval_globs) {
- lval_globs = &local_globs;
- }
- auto left = args[1]->pre_compile(code, lval_globs); // mutated (lvalue)
- auto rvect = new_tmp_vect(code);
- left.push_back(rvect[0]);
- for (var_idx_t v : left) {
- code.on_var_modification(v, here);
- }
- code.emplace_back(here, Op::_Let, std::move(left), std::move(right));
- add_set_globs(code, local_globs, here);
- return rvect;
- }
- case _ReturnSelf: {
- tolk_assert(args.size() == 2 && sym);
- Expr* this_arg = args[1];
- auto right = args[0]->pre_compile(code);
- return this_arg->pre_compile(code);
- }
- case _Var:
- case _Hole:
- if (val < 0) {
- throw ParseError{here, "unexpected variable definition"};
- }
- return {val};
- case _VarApply:
- if (args[0]->cls == _GlobFunc) {
- auto res = args[1]->pre_compile(code);
- auto rvect = new_tmp_vect(code);
- auto& op = code.emplace_back(here, Op::_Call, rvect, std::move(res), args[0]->sym);
- if (args[0]->flags & _IsImpure) {
- op.set_impure(code);
- }
- return rvect;
- } else {
- auto res = args[1]->pre_compile(code);
- auto tfunc = args[0]->pre_compile(code);
- if (tfunc.size() != 1) {
- throw Fatal{"stack tuple used as a function"};
- }
- res.push_back(tfunc[0]);
- auto rvect = new_tmp_vect(code);
- code.emplace_back(here, Op::_CallInd, rvect, std::move(res));
- return rvect;
- }
- case _Const: {
- auto rvect = new_tmp_vect(code);
- code.emplace_back(here, Op::_IntConst, rvect, intval);
- return rvect;
- }
- case _GlobFunc:
- case _GlobVar: {
- if (auto fun_ref = dynamic_cast<SymValFunc*>(sym->value)) {
- fun_ref->flags |= SymValFunc::flagUsedAsNonCall;
- if (!fun_ref->arg_order.empty() || !fun_ref->ret_order.empty()) {
- throw ParseError(here, "saving `" + sym->name() + "` into a variable will most likely lead to invalid usage, since it changes the order of variables on the stack");
- }
- if (fun_ref->has_mutate_params()) {
- throw ParseError(here, "saving `" + sym->name() + "` into a variable is impossible, since it has `mutate` parameters and thus can only be called directly");
- }
- }
- auto rvect = new_tmp_vect(code);
- if (lval_globs) {
- lval_globs->push_back({ sym, rvect[0] });
- return rvect;
- } else {
- code.emplace_back(here, Op::_GlobVar, rvect, std::vector<var_idx_t>{}, sym);
- return rvect;
- }
- }
- case _Letop: {
- return pre_compile_let(code, args.at(0), args.at(1), here);
- }
- case _MkTuple: {
- auto left = new_tmp_vect(code);
- auto right = args[0]->pre_compile(code);
- code.emplace_back(here, Op::_Tuple, left, std::move(right));
- return left;
- }
- case _CondExpr: {
- auto cond = args[0]->pre_compile(code);
- tolk_assert(cond.size() == 1);
- auto rvect = new_tmp_vect(code);
- Op& if_op = code.emplace_back(here, Op::_If, cond);
- code.push_set_cur(if_op.block0);
- code.emplace_back(here, Op::_Let, rvect, args[1]->pre_compile(code));
- code.close_pop_cur(args[1]->here);
- code.push_set_cur(if_op.block1);
- code.emplace_back(here, Op::_Let, rvect, args[2]->pre_compile(code));
- code.close_pop_cur(args[2]->here);
- return rvect;
- }
- case _SliceConst: {
- auto rvect = new_tmp_vect(code);
- code.emplace_back(here, Op::_SliceConst, rvect, strval);
- return rvect;
- }
- default:
- std::cerr << "expression constructor is " << cls << std::endl;
- throw Fatal{"cannot compile expression with unknown constructor"};
- }
-}
-
-} // namespace tolk
diff --git a/tolk/generics-helpers.cpp b/tolk/generics-helpers.cpp
new file mode 100644
index 000000000..3d353cc4e
--- /dev/null
+++ b/tolk/generics-helpers.cpp
@@ -0,0 +1,272 @@
+/*
+ This file is part of TON Blockchain Library.
+
+ TON Blockchain Library is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Lesser General Public License as published by
+ the Free Software Foundation, either version 2 of the License, or
+ (at your option) any later version.
+
+ TON Blockchain Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public License
+ along with TON Blockchain Library. If not, see <http://www.gnu.org/licenses/>.
+*/
+#include "generics-helpers.h"
+#include "tolk.h"
+#include "ast.h"
+#include "ast-replicator.h"
+#include "type-system.h"
+#include "compiler-state.h"
+#include "pipeline.h"
+
+namespace tolk {
+
+// given orig = "(int, T)" and substitutions = [slice], return "(int, slice)"
+static TypePtr replace_genericT_with_deduced(TypePtr orig, const GenericsDeclaration* genericTs, const std::vector<TypePtr>& substitutionTs) {
+ if (!orig || !orig->has_genericT_inside()) {
+ return orig;
+ }
+ tolk_assert(genericTs->size() == substitutionTs.size());
+
+ return orig->replace_children_custom([genericTs, substitutionTs](TypePtr child) {
+ if (const TypeDataGenericT* asT = child->try_as<TypeDataGenericT>()) {
+ int idx = genericTs->find_nameT(asT->nameT);
+ if (idx == -1) {
+ throw Fatal("can not replace generic " + asT->nameT);
+ }
+ return substitutionTs[idx];
+ }
+ return child;
+ });
+}
+
+// purpose: having `f<T>(value: T)` and call `f(5)`, deduce T = int
+// generally, there may be many generic Ts for declaration, and many arguments
+// for every argument, `consider_next_condition()` is called
+// example: `f<T1, T2>(a: int, b: T1, c: (T1, T2))` and call `f(6, 7, (8, cs))`
+// - `a` does not affect, it doesn't depend on generic Ts
+// - next condition: param_type = `T1`, arg_type = `int`, deduce T1 = int
+// - next condition: param_type = `(T1, T2)`, arg_type = `(int, slice)`, deduce T1 = int, T2 = slice
+// for call `f(6, cs, (8, cs))` T1 will be both `slice` and `int`, fired an error
+class GenericSubstitutionsDeduceForFunctionCall final {
+ const FunctionData* fun_ref;
+ std::vector<TypePtr> substitutions;
+
+ void provideDeducedT(const std::string& nameT, TypePtr deduced) {
+ if (deduced == TypeDataNullLiteral::create() || deduced->has_unknown_inside()) {
+ return; // just 'null' doesn't give sensible info
+ }
+
+ int idx = fun_ref->genericTs->find_nameT(nameT);
+ if (substitutions[idx] == nullptr) {
+ substitutions[idx] = deduced;
+ } else if (substitutions[idx] != deduced) {
+ throw std::runtime_error(nameT + " is both " + substitutions[idx]->as_human_readable() + " and " + deduced->as_human_readable());
+ }
+ }
+
+public:
+ explicit GenericSubstitutionsDeduceForFunctionCall(const FunctionData* fun_ref)
+ : fun_ref(fun_ref) {
+ substitutions.resize(fun_ref->genericTs->size()); // filled with nullptr (nothing deduced)
+ }
+
+ void consider_next_condition(TypePtr param_type, TypePtr arg_type) {
+ if (const auto* asT = param_type->try_as<TypeDataGenericT>()) {
+ // `(arg: T)` called as `f([1, 2])` => T is [int, int]
+ provideDeducedT(asT->nameT, arg_type);
+ } else if (const auto* p_tensor = param_type->try_as<TypeDataTensor>()) {
+ // `arg: (int, T)` called as `f((5, cs))` => T is slice
+ if (const auto* a_tensor = arg_type->try_as<TypeDataTensor>(); a_tensor && a_tensor->size() == p_tensor->size()) {
+ for (int i = 0; i < a_tensor->size(); ++i) {
+ consider_next_condition(p_tensor->items[i], a_tensor->items[i]);
+ }
+ }
+ } else if (const auto* p_tuple = param_type->try_as<TypeDataTypedTuple>()) {
+ // `arg: [int, T]` called as `f([5, cs])` => T is slice
+ if (const auto* a_tuple = arg_type->try_as<TypeDataTypedTuple>(); a_tuple && a_tuple->size() == p_tuple->size()) {
+ for (int i = 0; i < a_tuple->size(); ++i) {
+ consider_next_condition(p_tuple->items[i], a_tuple->items[i]);
+ }
+ }
+ } else if (const auto* p_callable = param_type->try_as<TypeDataFunCallable>()) {
+ // `arg: fun(TArg) -> TResult` called as `f(calcTupleLen)` => TArg is tuple, TResult is int
+ if (const auto* a_callable = arg_type->try_as<TypeDataFunCallable>(); a_callable && a_callable->params_size() == p_callable->params_size()) {
+ for (int i = 0; i < a_callable->params_size(); ++i) {
+ consider_next_condition(p_callable->params_types[i], a_callable->params_types[i]);
+ }
+ consider_next_condition(p_callable->return_type, a_callable->return_type);
+ }
+ }
+ }
+
+ int get_first_not_deduced_idx() const {
+ for (int i = 0; i < static_cast<int>(substitutions.size()); ++i) {
+ if (substitutions[i] == nullptr) {
+ return i;
+ }
+ }
+ return -1;
+ }
+
+ std::vector<TypePtr> flush() {
+ return {std::move(substitutions)};
+ }
+};
+
+// clone the body of `f<T>` replacing T everywhere with a substitution
+// before: `fun f<T>(v: T) { var cp: [T] = [v]; }`
+// after: `fun f<int>(v: int) { var cp: [int] = [v]; }`
+// an instantiated function becomes a deep copy, all AST nodes are copied, no previous pointers left
+class GenericFunctionReplicator final : public ASTReplicatorFunction {
+ const GenericsDeclaration* genericTs;
+ const std::vector<TypePtr>& substitutionTs;
+
+protected:
+ using ASTReplicatorFunction::clone;
+
+ TypePtr clone(TypePtr t) override {
+ return replace_genericT_with_deduced(t, genericTs, substitutionTs);
+ }
+
+public:
+ GenericFunctionReplicator(const GenericsDeclaration* genericTs, const std::vector<TypePtr>& substitutionTs)
+ : genericTs(genericTs)
+ , substitutionTs(substitutionTs) {
+ }
+
+ V<ast_function_declaration> clone_function_body(V<ast_function_declaration> v_function) override {
+ return createV<ast_function_declaration>(
+ v_function->loc,
+ clone(v_function->get_identifier()),
+ clone(v_function->get_param_list()),
+ clone(v_function->get_body()),
+ clone(v_function->declared_return_type),
+ nullptr, // a newly-created function is not generic
+ v_function->method_id,
+ v_function->flags
+ );
+ }
+};
+
+std::string GenericsDeclaration::as_human_readable() const {
+ std::string result = "<";
+ for (const GenericsItem& item : itemsT) {
+ if (result.size() > 1) {
+ result += ",";
+ }
+ result += item.nameT;
+ }
+ result += ">";
+ return result;
+}
+
+int GenericsDeclaration::find_nameT(std::string_view nameT) const {
+ for (int i = 0; i < static_cast<int>(itemsT.size()); ++i) {
+ if (itemsT[i].nameT == nameT) {
+ return i;
+ }
+ }
+ return -1;
+}
+
+// after creating a deep copy of `f<T>` like `f<int>`, its new and fresh body needs the previous pipeline to run
+// for example, all local vars need to be registered as symbols, etc.
+static void run_pipeline_for_instantiated_function(const FunctionData* inst_fun_ref) {
+ // these pipes are exactly the same as in tolk.cpp — all preceding (and including) type inferring
+ pipeline_resolve_identifiers_and_assign_symbols(inst_fun_ref);
+ pipeline_calculate_rvalue_lvalue(inst_fun_ref);
+ pipeline_detect_unreachable_statements(inst_fun_ref);
+ pipeline_infer_types_and_calls_and_fields(inst_fun_ref);
+}
+
+std::string generate_instantiated_name(const std::string& orig_name, const std::vector<TypePtr>& substitutions) {
+ // an instantiated function name will be "{orig_name}<{T1,T2,...}>"
+ std::string name = orig_name;
+ name += "<";
+ for (TypePtr subs : substitutions) {
+ if (name.size() > orig_name.size() + 1) {
+ name += ",";
+ }
+ name += subs->as_human_readable();
+ }
+ name.erase(std::remove(name.begin(), name.end(), ' '), name.end());
+ name += ">";
+ return name;
+}
+
+td::Result<std::vector<TypePtr>> deduce_substitutionTs_on_generic_func_call(const FunctionData* called_fun, std::vector<TypePtr>&& arg_types, TypePtr return_hint) {
+ try {
+ GenericSubstitutionsDeduceForFunctionCall deducing(called_fun);
+ for (const LocalVarData& param : called_fun->parameters) {
+ if (param.declared_type->has_genericT_inside() && param.idx < static_cast<int>(arg_types.size())) {
+ deducing.consider_next_condition(param.declared_type, arg_types[param.idx]);
+ }
+ }
+ int idx = deducing.get_first_not_deduced_idx();
+ if (idx != -1 && return_hint && called_fun->declared_return_type->has_genericT_inside()) {
+ deducing.consider_next_condition(called_fun->declared_return_type, return_hint);
+ idx = deducing.get_first_not_deduced_idx();
+ }
+ if (idx != -1) {
+ return td::Status::Error(td::Slice{"can not deduce " + called_fun->genericTs->get_nameT(idx)});
+ }
+ return deducing.flush();
+ } catch (const std::runtime_error& ex) {
+ return td::Status::Error(td::Slice{ex.what()});
+ }
+}
+
+const FunctionData* instantiate_generic_function(SrcLocation loc, const FunctionData* fun_ref, const std::string& inst_name, std::vector<TypePtr>&& substitutionTs) {
+ tolk_assert(fun_ref->genericTs);
+
+ // if `f<int>` was earlier instantiated, return it
+ if (const auto* existing = lookup_global_symbol(inst_name)) {
+ const FunctionData* inst_ref = existing->try_as<FunctionData>();
+ tolk_assert(inst_ref);
+ return inst_ref;
+ }
+
+ std::vector<LocalVarData> parameters;
+ parameters.reserve(fun_ref->get_num_params());
+ for (const LocalVarData& orig_p : fun_ref->parameters) {
+ parameters.emplace_back(orig_p.name, orig_p.loc, replace_genericT_with_deduced(orig_p.declared_type, fun_ref->genericTs, substitutionTs), orig_p.flags, orig_p.idx);
+ }
+ TypePtr declared_return_type = replace_genericT_with_deduced(fun_ref->declared_return_type, fun_ref->genericTs, substitutionTs);
+ const GenericsInstantiation* instantiationTs = new GenericsInstantiation(loc, std::move(substitutionTs));
+
+ if (fun_ref->is_asm_function()) {
+ FunctionData* inst_ref = new FunctionData(inst_name, fun_ref->loc, declared_return_type, std::move(parameters), fun_ref->flags, nullptr, instantiationTs, new FunctionBodyAsm, fun_ref->ast_root);
+ inst_ref->arg_order = fun_ref->arg_order;
+ inst_ref->ret_order = fun_ref->ret_order;
+ G.symtable.add_function(inst_ref);
+ G.all_functions.push_back(inst_ref);
+ run_pipeline_for_instantiated_function(inst_ref);
+ return inst_ref;
+ }
+
+ if (fun_ref->is_builtin_function()) {
+ FunctionData* inst_ref = new FunctionData(inst_name, fun_ref->loc, declared_return_type, std::move(parameters), fun_ref->flags, nullptr, instantiationTs, fun_ref->body, fun_ref->ast_root);
+ inst_ref->arg_order = fun_ref->arg_order;
+ inst_ref->ret_order = fun_ref->ret_order;
+ G.symtable.add_function(inst_ref);
+ return inst_ref;
+ }
+
+ GenericFunctionReplicator replicator(fun_ref->genericTs, instantiationTs->substitutions);
+ V<ast_function_declaration> inst_root = replicator.clone_function_body(fun_ref->ast_root->as<ast_function_declaration>());
+
+ FunctionData* inst_ref = new FunctionData(inst_name, fun_ref->loc, declared_return_type, std::move(parameters), fun_ref->flags, nullptr, instantiationTs, new FunctionBodyCode, inst_root);
+ inst_ref->arg_order = fun_ref->arg_order;
+ inst_ref->ret_order = fun_ref->ret_order;
+ inst_root->mutate()->assign_fun_ref(inst_ref);
+ G.symtable.add_function(inst_ref);
+ G.all_functions.push_back(inst_ref);
+ run_pipeline_for_instantiated_function(inst_ref);
+ return inst_ref;
+}
+
+} // namespace tolk
diff --git a/tolk/generics-helpers.h b/tolk/generics-helpers.h
new file mode 100644
index 000000000..2a304f55b
--- /dev/null
+++ b/tolk/generics-helpers.h
@@ -0,0 +1,64 @@
+/*
+ This file is part of TON Blockchain Library.
+
+ TON Blockchain Library is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Lesser General Public License as published by
+ the Free Software Foundation, either version 2 of the License, or
+ (at your option) any later version.
+
+ TON Blockchain Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public License
+ along with TON Blockchain Library. If not, see <http://www.gnu.org/licenses/>.
+*/
+#pragma once
+
+#include "src-file.h"
+#include "fwd-declarations.h"
+#include "td/utils/Status.h"
+#include <vector>
+
+namespace tolk {
+
+// when a function is declared `f<T>`, this "<T>" is represented as this class
+// (not at AST, but at symbol storage level)
+struct GenericsDeclaration {
+ struct GenericsItem {
+ std::string_view nameT;
+
+ explicit GenericsItem(std::string_view nameT)
+ : nameT(nameT) {}
+ };
+
+ explicit GenericsDeclaration(std::vector<GenericsItem>&& itemsT)
+ : itemsT(std::move(itemsT)) {}
+
+ const std::vector<GenericsItem> itemsT;
+
+ std::string as_human_readable() const;
+
+ size_t size() const { return itemsT.size(); }
+ bool has_nameT(std::string_view nameT) const { return find_nameT(nameT) != -1; }
+ int find_nameT(std::string_view nameT) const;
+ std::string get_nameT(int idx) const { return static_cast<std::string>(itemsT[idx].nameT); }
+};
+
+// when a function call is `f<int>()`, this "<int>" is represented as this class
+struct GenericsInstantiation {
+ const std::vector<TypePtr> substitutions; // <SomeStruct, int> for genericTs <T1, T2>
+ const SrcLocation loc; // first instantiation location
+
+ explicit GenericsInstantiation(SrcLocation loc, std::vector<TypePtr>&& substitutions)
+ : substitutions(std::move(substitutions))
+ , loc(loc) {
+ }
+};
+
+std::string generate_instantiated_name(const std::string& orig_name, const std::vector<TypePtr>& substitutions);
+td::Result<std::vector<TypePtr>> deduce_substitutionTs_on_generic_func_call(const FunctionData* called_fun, std::vector<TypePtr>&& arg_types, TypePtr return_hint);
+const FunctionData* instantiate_generic_function(SrcLocation loc, const FunctionData* fun_ref, const std::string& inst_name, std::vector<TypePtr>&& substitutionTs);
+
+} // namespace tolk
diff --git a/tolk/lexer.cpp b/tolk/lexer.cpp
index 17eb4544c..7e8c8fb2d 100644
--- a/tolk/lexer.cpp
+++ b/tolk/lexer.cpp
@@ -15,9 +15,9 @@
along with TON Blockchain Library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "lexer.h"
-#include "compiler-state.h"
-#include "symtable.h"
#include <cassert>
+#include <cstdint>
+#include <cstring>
namespace tolk {
@@ -328,6 +328,7 @@ struct ChunkIdentifierOrKeyword final : ChunkLexerBase {
case 2:
if (str == "do") return tok_do;
if (str == "if") return tok_if;
+ if (str == "as") return tok_as;
break;
case 3:
if (str == "int") return tok_int;
@@ -345,7 +346,6 @@ struct ChunkIdentifierOrKeyword final : ChunkLexerBase {
if (str == "null") return tok_null;
if (str == "void") return tok_void;
if (str == "bool") return tok_bool;
- if (str == "auto") return tok_auto;
if (str == "self") return tok_self;
if (str == "tolk") return tok_tolk;
if (str == "type") return tok_type;
@@ -406,7 +406,6 @@ struct ChunkIdentifierOrKeyword final : ChunkLexerBase {
if (TokenType kw_tok = maybe_keyword(str_val)) {
lex->add_token(kw_tok, str_val);
} else {
- G.symbols.lookup_add(str_val);
lex->add_token(tok_identifier, str_val);
}
return true;
@@ -421,7 +420,7 @@ struct ChunkIdentifierInBackticks final : ChunkLexerBase {
const char* str_begin = lex->c_str();
lex->skip_chars(1);
while (!lex->is_eof() && lex->char_at() != '`' && lex->char_at() != '\n') {
- if (std::isspace(lex->char_at())) { // probably, I'll remove this restriction after rewriting symtable and cur_sym_idx
+ if (std::isspace(lex->char_at())) {
lex->error("an identifier can't have a space in its name (even inside backticks)");
}
lex->skip_chars(1);
@@ -432,7 +431,6 @@ struct ChunkIdentifierInBackticks final : ChunkLexerBase {
std::string_view str_val(str_begin + 1, lex->c_str() - str_begin - 1);
lex->skip_chars(1);
- G.symbols.lookup_add(str_val);
lex->add_token(tok_identifier, str_val);
return true;
}
@@ -580,6 +578,16 @@ void Lexer::next_special(TokenType parse_next_as, const char* str_expected) {
cur_token = tokens_circularbuf[++cur_token_idx & 7];
}
+Lexer::SavedPositionForLookahead Lexer::save_parsing_position() const {
+ return {p_next, cur_token_idx, cur_token};
+}
+
+void Lexer::restore_position(SavedPositionForLookahead saved) {
+ p_next = saved.p_next;
+ cur_token_idx = last_token_idx = saved.cur_token_idx;
+ cur_token = saved.cur_token;
+}
+
void Lexer::error(const std::string& err_msg) const {
throw ParseError(cur_location(), err_msg);
}
@@ -597,7 +605,7 @@ void lexer_init() {
// Hence, it's difficult to measure Lexer performance separately.
// This function can be called just to tick Lexer performance, it just scans all input files.
// There is no sense to use it in production, but when refactoring and optimizing Lexer, it's useful.
-void lexer_measure_performance(const AllSrcFiles& files_to_just_parse) {
+void lexer_measure_performance(const AllRegisteredSrcFiles& files_to_just_parse) {
for (const SrcFile* file : files_to_just_parse) {
Lexer lex(file);
while (!lex.is_eof()) {
diff --git a/tolk/lexer.h b/tolk/lexer.h
index 8a25f9526..81d579db0 100644
--- a/tolk/lexer.h
+++ b/tolk/lexer.h
@@ -57,10 +57,29 @@ enum TokenType {
tok_dot,
tok_plus,
+ tok_set_plus,
tok_minus,
+ tok_set_minus,
tok_mul,
+ tok_set_mul,
tok_div,
+ tok_set_div,
tok_mod,
+ tok_set_mod,
+ tok_lshift,
+ tok_set_lshift,
+ tok_rshift,
+ tok_set_rshift,
+ tok_rshiftR,
+ tok_rshiftC,
+ tok_bitwise_and,
+ tok_set_bitwise_and,
+ tok_bitwise_or,
+ tok_set_bitwise_or,
+ tok_bitwise_xor,
+ tok_set_bitwise_xor,
+ tok_bitwise_not,
+
tok_question,
tok_comma,
tok_semicolon,
@@ -77,32 +96,14 @@ enum TokenType {
tok_logical_not,
tok_logical_and,
tok_logical_or,
- tok_bitwise_and,
- tok_bitwise_or,
- tok_bitwise_xor,
- tok_bitwise_not,
tok_eq,
tok_neq,
tok_leq,
tok_geq,
tok_spaceship,
- tok_lshift,
- tok_rshift,
- tok_rshiftR,
- tok_rshiftC,
tok_divR,
tok_divC,
- tok_set_plus,
- tok_set_minus,
- tok_set_mul,
- tok_set_div,
- tok_set_mod,
- tok_set_lshift,
- tok_set_rshift,
- tok_set_bitwise_and,
- tok_set_bitwise_or,
- tok_set_bitwise_xor,
tok_return,
tok_repeat,
@@ -124,9 +125,9 @@ enum TokenType {
tok_builder,
tok_continuation,
tok_tuple,
- tok_auto,
tok_void,
tok_arrow,
+ tok_as,
tok_tolk,
tok_semver,
@@ -165,6 +166,12 @@ class Lexer {
public:
+ struct SavedPositionForLookahead {
+ const char* p_next = nullptr;
+ int cur_token_idx = 0;
+ Token cur_token;
+ };
+
explicit Lexer(const SrcFile* file);
Lexer(const Lexer&) = delete;
Lexer &operator=(const Lexer&) = delete;
@@ -208,6 +215,9 @@ class Lexer {
void next();
void next_special(TokenType parse_next_as, const char* str_expected);
+ SavedPositionForLookahead save_parsing_position() const;
+ void restore_position(SavedPositionForLookahead saved);
+
void check(TokenType next_tok, const char* str_expected) const {
if (cur_token.type != next_tok) {
unexpected(str_expected); // unlikely path, not inlined
@@ -229,6 +239,6 @@ class Lexer {
void lexer_init();
// todo #ifdef TOLK_PROFILING
-void lexer_measure_performance(const AllSrcFiles& files_to_just_parse);
+void lexer_measure_performance(const AllRegisteredSrcFiles& files_to_just_parse);
} // namespace tolk
diff --git a/tolk/pipe-ast-to-legacy.cpp b/tolk/pipe-ast-to-legacy.cpp
index 7257bfb07..d60bb8b34 100644
--- a/tolk/pipe-ast-to-legacy.cpp
+++ b/tolk/pipe-ast-to-legacy.cpp
@@ -17,1068 +17,561 @@
#include "tolk.h"
#include "src-file.h"
#include "ast.h"
-#include "compiler-state.h"
+#include "ast-visitor.h"
+#include "type-system.h"
#include "common/refint.h"
-#include "openssl/digest.hpp"
-#include "crypto/common/util.h"
-#include "td/utils/crypto.h"
-#include "ton/ton-types.h"
+#include "constant-evaluator.h"
/*
- * In this module, we convert modern AST representation to legacy representation
- * (global state, Expr, CodeBlob, etc.) to make the rest of compiling process remain unchanged for now.
- * Since time goes, I'll gradually get rid of legacy, since most of the code analysis
- * should be done at AST level.
+ * This pipe is the last one operating AST: it transforms AST to IR.
+ * IR is described as "Op" struct. So, here AST is transformed to Ops, and then all the rest "legacy"
+ * kernel (initially forked from FunC) comes into play.
+ * Up to this point, all types have been inferred, all validity checks have been passed, etc.
+ * All properties in AST nodes are assigned and can be safely used (fun_ref, etc.).
+ * So, if execution reaches this pass, the input is correct, and code generation should succeed.
*/
namespace tolk {
-static int calc_sym_idx(std::string_view sym_name) {
- return G.symbols.lookup(sym_name);
-}
-
-void Expr::fire_error_rvalue_expected() const {
- // generally, almost all vertices are rvalue, that's why code leading to "not rvalue"
- // should be very strange, like `var x = _`
- throw ParseError(here, "rvalue expected");
-}
+struct LValGlobs {
+ std::vector<std::pair<const GlobalVarData*, var_idx_t>> globs;
-void Expr::fire_error_lvalue_expected(const std::string& details) const {
- // "lvalue expected" is when a user modifies something unmodifiable
- // example: `f() = 32`
- // example: `loadUint(c.beginParse(), 32)` (since `loadUint()` mutates the first argument)
- throw ParseError(here, "lvalue expected (" + details + ")");
-}
+ void add_modified_glob(const GlobalVarData* g_sym, var_idx_t local_ir_idx) {
+ globs.emplace_back(g_sym, local_ir_idx);
+ }
-void Expr::fire_error_modifying_immutable(const std::string& details) const {
- // "modifying immutable variable" is when a user assigns to a variable declared `val`
- // example: `immutable_val = 32`
- // example: `(regular_var, immutable_val) = f()`
- // for better error message, try to print out variable name if possible
- std::string variable_name;
- if (cls == _Var || cls == _Const) {
- variable_name = sym->name();
- } else if (cls == _Tensor || cls == _MkTuple) {
- for (const Expr* arg : (cls == _Tensor ? args : args[0]->args)) {
- if (arg->is_immutable() && (arg->cls == _Var || arg->cls == _Const)) {
- variable_name = arg->sym->name();
- break;
- }
+ void gen_ops_set_globs(CodeBlob& code, SrcLocation loc) const {
+ for (const auto& [g_sym, ir_idx] : globs) {
+ Op& op = code.emplace_back(loc, Op::_SetGlob, std::vector<var_idx_t>{}, std::vector<var_idx_t>{ ir_idx }, g_sym);
+ op.set_impure_flag();
}
}
+};
- if (variable_name == "self") {
- throw ParseError(here, "modifying `self` (" + details + "), which is immutable by default; probably, you want to declare `mutate self`");
- } else if (!variable_name.empty()) {
- throw ParseError(here, "modifying an immutable variable `" + variable_name + "` (" + details + ")");
- } else {
- throw ParseError(here, "modifying an immutable variable (" + details + ")");
- }
-}
+std::vector<var_idx_t> pre_compile_expr(AnyExprV v, CodeBlob& code, LValGlobs* lval_globs = nullptr);
+void process_any_statement(AnyV v, CodeBlob& code);
-GNU_ATTRIBUTE_COLD GNU_ATTRIBUTE_NORETURN
-static void fire_error_invalid_mutate_arg_passed(SrcLocation loc, const SymDef* func_sym, const SymDef* param_sym, bool called_as_method, bool arg_passed_as_mutate, AnyV arg_expr) {
- std::string func_name = func_sym->name();
- std::string arg_str(arg_expr->type == ast_identifier ? arg_expr->as<ast_identifier>()->name : "obj");
- const SymValFunc* func_val = dynamic_cast<const SymValFunc*>(func_sym->value);
- const SymValVariable* param_val = dynamic_cast<const SymValVariable*>(param_sym->value);
- // case: `loadInt(cs, 32)`; suggest: `cs.loadInt(32)`
- if (param_val->is_mutate_parameter() && !arg_passed_as_mutate && !called_as_method && param_val->idx == 0 && func_val->does_accept_self()) {
- throw ParseError(loc, "`" + func_name + "` is a mutating method; consider calling `" + arg_str + "." + func_name + "()`, not `" + func_name + "(" + arg_str + ")`");
+static std::vector<std::vector<var_idx_t>> pre_compile_tensor_inner(CodeBlob& code, const std::vector<AnyExprV>& args,
+ LValGlobs* lval_globs) {
+ const int n = static_cast<int>(args.size());
+ if (n == 0) { // just `()`
+ return {};
}
- // case: `cs.mutating_function()`; suggest: `mutating_function(mutate cs)` or make it a method
- if (param_val->is_mutate_parameter() && called_as_method && param_val->idx == 0 && !func_val->does_accept_self()) {
- throw ParseError(loc, "function `" + func_name + "` mutates parameter `" + param_sym->name() + "`; consider calling `" + func_name + "(mutate " + arg_str + ")`, not `" + arg_str + "." + func_name + "`(); alternatively, rename parameter to `self` to make it a method");
+ if (n == 1) { // just `(x)`: even if x is modified (e.g. `f(x=x+2)`), there are no next arguments
+ return {pre_compile_expr(args[0], code, lval_globs)};
}
- // case: `mutating_function(arg)`; suggest: `mutate arg`
- if (param_val->is_mutate_parameter() && !arg_passed_as_mutate) {
- throw ParseError(loc, "function `" + func_name + "` mutates parameter `" + param_sym->name() + "`; you need to specify `mutate` when passing an argument, like `mutate " + arg_str + "`");
- }
- // case: `usual_function(mutate arg)`
- if (!param_val->is_mutate_parameter() && arg_passed_as_mutate) {
- throw ParseError(loc, "incorrect `mutate`, since `" + func_name + "` does not mutate this parameter");
- }
- throw Fatal("unreachable");
-}
-// parse address like "EQCRDM9h4k3UJdOePPuyX40mCgA4vxge5Dc5vjBR8djbEKC5"
-// based on unpack_std_smc_addr() from block.cpp
-// (which is not included to avoid linking with ton_crypto)
-static bool parse_friendly_address(const char packed[48], ton::WorkchainId& workchain, ton::StdSmcAddress& addr) {
- unsigned char buffer[36];
- if (!td::buff_base64_decode(td::MutableSlice{buffer, 36}, td::Slice{packed, 48}, true)) {
- return false;
- }
- td::uint16 crc = td::crc16(td::Slice{buffer, 34});
- if (buffer[34] != (crc >> 8) || buffer[35] != (crc & 0xff) || (buffer[0] & 0x3f) != 0x11) {
- return false;
- }
- workchain = (td::int8)buffer[1];
- std::memcpy(addr.data(), buffer + 2, 32);
- return true;
-}
+ // the purpose is to handle such cases: `return (x, x += y, x)`
+ // without this, ops will be { _Call $2 = +($0_x, $1_y); _Return $0_x, $2, $0_x } - invalid
+ // with this, ops will be { _Let $3 = $0_x; _Call $2 = ...; _Return $3, $2, $0_x } - valid, tmp var for x
+ // how it works: for every arg, after transforming to ops, start tracking ir_idx inside it
+ // on modification attempt, create Op::_Let to a tmp var and replace old ir_idx with tmp_idx in result
+ struct WatchingVarList {
+ std::vector<var_idx_t> watched_vars;
+ std::vector<std::vector<var_idx_t>> res_lists;
-// parse address like "0:527964d55cfa6eb731f4bfc07e9d025098097ef8505519e853986279bd8400d8"
-// based on StdAddress::parse_addr() from block.cpp
-// (which is not included to avoid linking with ton_crypto)
-static bool parse_raw_address(const std::string& acc_string, int& workchain, ton::StdSmcAddress& addr) {
- size_t pos = acc_string.find(':');
- if (pos != std::string::npos) {
- td::Result<int> r_wc = td::to_integer_safe<ton::WorkchainId>(acc_string.substr(0, pos));
- if (r_wc.is_error()) {
- return false;
+ explicit WatchingVarList(int n_args) {
+ res_lists.reserve(n_args);
}
- workchain = r_wc.move_as_ok();
- pos++;
- } else {
- pos = 0;
- }
- if (acc_string.size() != pos + 64) {
- return false;
- }
- for (int i = 0; i < 64; ++i) { // loop through each hex digit
- char c = acc_string[pos + i];
- int x;
- if (c >= '0' && c <= '9') {
- x = c - '0';
- } else if (c >= 'a' && c <= 'z') {
- x = c - 'a' + 10;
- } else if (c >= 'A' && c <= 'Z') {
- x = c - 'A' + 10;
- } else {
- return false;
+ bool is_watched(var_idx_t ir_idx) const {
+ return std::find(watched_vars.begin(), watched_vars.end(), ir_idx) != watched_vars.end();
}
- if ((i & 1) == 0) {
- addr.data()[i >> 1] = static_cast<unsigned char>((addr.data()[i >> 1] & 0x0F) | (x << 4));
- } else {
- addr.data()[i >> 1] = static_cast<unsigned char>((addr.data()[i >> 1] & 0xF0) | x);
+ void add_and_watch_modifications(std::vector<var_idx_t>&& vars_of_ith_arg, CodeBlob& code) {
+ for (var_idx_t ir_idx : vars_of_ith_arg) {
+ if (code.vars[ir_idx].v_sym && !is_watched(ir_idx)) {
+ watched_vars.emplace_back(ir_idx);
+ code.vars[ir_idx].on_modification.emplace_back([this, &code, ir_idx](SrcLocation loc) {
+ on_var_modified(ir_idx, loc, code);
+ });
+ }
+ }
+ res_lists.emplace_back(std::move(vars_of_ith_arg));
}
- }
- return true;
-}
-
-static Expr* create_expr_apply(SrcLocation loc, SymDef* sym, std::vector<Expr*>&& args) {
- Expr* apply = new Expr(Expr::_Apply, sym, std::move(args));
- apply->here = loc;
- apply->flags = Expr::_IsRvalue;
- apply->deduce_type();
- return apply;
-}
-
-static Expr* create_expr_int_const(SrcLocation loc, int int_val) {
- Expr* int_const = new Expr(Expr::_Const, loc);
- int_const->intval = td::make_refint(int_val);
- int_const->flags = Expr::_IsRvalue;
- int_const->e_type = TypeExpr::new_atomic(TypeExpr::_Int);
- return int_const;
-}
-
-namespace blk_fl {
-enum { end = 1, ret = 2, empty = 4 };
-typedef int val;
-constexpr val init = end | empty;
-void combine(val& x, const val y) {
- x |= y & ret;
- x &= y | ~(end | empty);
-}
-void combine_parallel(val& x, const val y) {
- x &= y | ~(ret | empty);
- x |= y & end;
-}
-} // namespace blk_fl
-
-Expr* process_expr(AnyV v, CodeBlob& code);
-blk_fl::val process_statement(AnyV v, CodeBlob& code);
-
-static void check_global_func(SrcLocation loc, sym_idx_t func_name) {
- SymDef* sym_def = lookup_symbol(func_name);
- if (!sym_def) {
- throw ParseError(loc, "undefined symbol `" + G.symbols.get_name(func_name) + "`");
- }
-}
-static void check_import_exists_when_using_sym(AnyV v_usage, const SymDef* used_sym) {
- if (!v_usage->loc.is_symbol_from_same_or_builtin_file(used_sym->loc)) {
- const SrcFile* declared_in = used_sym->loc.get_src_file();
- bool has_import = false;
- for (const SrcFile::ImportStatement& import_stmt : v_usage->loc.get_src_file()->imports) {
- if (import_stmt.imported_file == declared_in) {
- has_import = true;
+ void on_var_modified(var_idx_t ir_idx, SrcLocation loc, CodeBlob& code) {
+ tolk_assert(is_watched(ir_idx));
+ var_idx_t tmp_idx = code.create_tmp_var(code.vars[ir_idx].v_type, loc);
+ code.emplace_back(loc, Op::_Let, std::vector{tmp_idx}, std::vector{ir_idx});
+ for (std::vector<var_idx_t>& prev_vars : res_lists) {
+ std::replace(prev_vars.begin(), prev_vars.end(), ir_idx, tmp_idx);
}
}
- if (!has_import) {
- v_usage->error("Using a non-imported symbol `" + used_sym->name() + "`. Forgot to import \"" + declared_in->rel_filename + "\"?");
- }
- }
-}
-static Expr* create_new_local_variable(SrcLocation loc, std::string_view var_name, TypeExpr* var_type, bool is_immutable) {
- SymDef* sym = lookup_symbol(calc_sym_idx(var_name));
- if (sym) { // creating a new variable, but something found in symtable
- if (sym->level != G.scope_level) {
- sym = nullptr; // declaring a new variable with the same name, but in another scope
- } else {
- throw ParseError(loc, "redeclaration of local variable `" + static_cast<std::string>(var_name) + "`");
+ std::vector<std::vector<var_idx_t>> clear_and_stop_watching(CodeBlob& code) {
+ for (var_idx_t ir_idx : watched_vars) {
+ code.vars[ir_idx].on_modification.pop_back();
+ }
+ watched_vars.clear();
+ return std::move(res_lists);
}
+ };
+
+ WatchingVarList watched_vars(n);
+ for (int arg_idx = 0; arg_idx < n; ++arg_idx) {
+ std::vector<var_idx_t> vars_of_ith_arg = pre_compile_expr(args[arg_idx], code, lval_globs);
+ watched_vars.add_and_watch_modifications(std::move(vars_of_ith_arg), code);
}
- Expr* x = new Expr{Expr::_Var, loc};
- x->val = ~calc_sym_idx(var_name);
- x->e_type = var_type;
- x->flags = Expr::_IsLvalue | (is_immutable ? Expr::_IsImmutable : 0);
- return x;
+ return watched_vars.clear_and_stop_watching(code);
}
-static Expr* create_new_underscore_variable(SrcLocation loc, TypeExpr* var_type) {
- Expr* x = new Expr{Expr::_Hole, loc};
- x->val = -1;
- x->flags = Expr::_IsLvalue;
- x->e_type = var_type;
- return x;
+static std::vector<var_idx_t> pre_compile_tensor(CodeBlob& code, const std::vector<AnyExprV>& args,
+ LValGlobs* lval_globs = nullptr) {
+ std::vector<std::vector<var_idx_t>> res_lists = pre_compile_tensor_inner(code, args, lval_globs);
+ std::vector<var_idx_t> res;
+ for (const std::vector<var_idx_t>& list : res_lists) {
+ res.insert(res.end(), list.cbegin(), list.cend());
+ }
+ return res;
}
-static Expr* process_expr(V<ast_binary_operator> v, CodeBlob& code) {
- TokenType t = v->tok;
- std::string operator_name = static_cast<std::string>(v->operator_name);
-
- if (t == tok_set_plus || t == tok_set_minus || t == tok_set_mul || t == tok_set_div ||
- t == tok_set_mod || t == tok_set_lshift || t == tok_set_rshift ||
- t == tok_set_bitwise_and || t == tok_set_bitwise_or || t == tok_set_bitwise_xor) {
- Expr* x = process_expr(v->get_lhs(), code);
- x->chk_rvalue();
- if (!x->is_lvalue()) {
- x->fire_error_lvalue_expected("left side of assignment");
- }
- if (x->is_immutable()) {
- x->fire_error_modifying_immutable("left side of assignment");
+static std::vector<var_idx_t> pre_compile_let(CodeBlob& code, AnyExprV lhs, AnyExprV rhs, SrcLocation loc) {
+ // [lhs] = [rhs]; since type checking is ok, it's the same as "lhs = rhs"
+ if (lhs->type == ast_typed_tuple && rhs->type == ast_typed_tuple) {
+ std::vector<var_idx_t> right = pre_compile_tensor(code, rhs->as<ast_typed_tuple>()->get_items());
+ LValGlobs globs;
+ std::vector<var_idx_t> left = pre_compile_tensor(code, lhs->as<ast_typed_tuple>()->get_items(), &globs);
+ code.on_var_modification(left, loc);
+ code.emplace_back(loc, Op::_Let, std::move(left), right);
+ globs.gen_ops_set_globs(code, loc);
+ return right;
+ }
+ // [lhs] = rhs; it's un-tuple to N left vars
+ if (lhs->type == ast_typed_tuple) {
+ std::vector<var_idx_t> right = pre_compile_expr(rhs, code);
+ const TypeDataTypedTuple* inferred_tuple = rhs->inferred_type->try_as<TypeDataTypedTuple>();
+ std::vector<TypePtr> types_list = inferred_tuple->items;
+ std::vector<var_idx_t> rvect = {code.create_tmp_var(TypeDataTensor::create(std::move(types_list)), rhs->loc)};
+ code.emplace_back(lhs->loc, Op::_UnTuple, rvect, std::move(right));
+ LValGlobs globs;
+ std::vector<var_idx_t> left = pre_compile_tensor(code, lhs->as<ast_typed_tuple>()->get_items(), &globs);
+ code.on_var_modification(left, loc);
+ code.emplace_back(loc, Op::_Let, std::move(left), rvect);
+ globs.gen_ops_set_globs(code, loc);
+ return rvect;
+ }
+ // lhs = rhs
+ std::vector<var_idx_t> right = pre_compile_expr(rhs, code);
+ LValGlobs globs;
+ std::vector<var_idx_t> left = pre_compile_expr(lhs, code, &globs);
+ code.on_var_modification(left, loc);
+ code.emplace_back(loc, Op::_Let, std::move(left), right);
+ globs.gen_ops_set_globs(code, loc);
+ return right;
+}
+
+static std::vector<var_idx_t> gen_op_call(CodeBlob& code, TypePtr ret_type, SrcLocation here,
+ std::vector<var_idx_t>&& args_vars, const FunctionData* fun_ref) {
+ std::vector<var_idx_t> rvect = {code.create_tmp_var(ret_type, here)};
+ Op& op = code.emplace_back(here, Op::_Call, rvect, std::move(args_vars), fun_ref);
+ if (!fun_ref->is_marked_as_pure()) {
+ op.set_impure_flag();
+ }
+ return rvect;
+}
+
+
+static std::vector<var_idx_t> process_symbol(SrcLocation loc, const Symbol* sym, CodeBlob& code, LValGlobs* lval_globs) {
+ if (const auto* glob_ref = sym->try_as<GlobalVarData>()) {
+ std::vector<var_idx_t> rvect = {code.create_tmp_var(glob_ref->declared_type, loc)};
+ if (lval_globs) {
+ lval_globs->add_modified_glob(glob_ref, rvect[0]);
+ return rvect;
+ } else {
+ code.emplace_back(loc, Op::_GlobVar, rvect, std::vector<var_idx_t>{}, glob_ref);
+ return rvect;
}
- SymDef* sym = lookup_symbol(calc_sym_idx("^_" + operator_name + "_"));
- Expr* y = process_expr(v->get_rhs(), code);
- y->chk_rvalue();
- Expr* z = create_expr_apply(v->loc, sym, {x, y});
- Expr* res = new Expr{Expr::_Letop, {x->copy(), z}};
- res->here = v->loc;
- res->flags = x->flags | Expr::_IsRvalue;
- res->deduce_type();
- return res;
}
- if (t == tok_assign) {
- Expr* x = process_expr(v->get_lhs(), code);
- if (!x->is_lvalue()) {
- x->fire_error_lvalue_expected("left side of assignment");
- }
- if (x->is_immutable()) {
- x->fire_error_modifying_immutable("left side of assignment");
+ if (const auto* const_ref = sym->try_as<GlobalConstData>()) {
+ if (const_ref->is_int_const()) {
+ std::vector<var_idx_t> rvect = {code.create_tmp_var(TypeDataInt::create(), loc)};
+ code.emplace_back(loc, Op::_IntConst, rvect, const_ref->as_int_const());
+ return rvect;
+ } else {
+ std::vector<var_idx_t> rvect = {code.create_tmp_var(TypeDataSlice::create(), loc)};
+ code.emplace_back(loc, Op::_SliceConst, rvect, const_ref->as_slice_const());
+ return rvect;
}
- Expr* y = process_expr(v->get_rhs(), code);
- y->chk_rvalue();
- x->predefine_vars();
- x->define_new_vars(code);
- Expr* res = new Expr{Expr::_Letop, {x, y}};
- res->here = v->loc;
- res->flags = x->flags | Expr::_IsRvalue;
- res->deduce_type();
- return res;
}
- if (t == tok_minus || t == tok_plus ||
- t == tok_bitwise_and || t == tok_bitwise_or || t == tok_bitwise_xor ||
- t == tok_eq || t == tok_lt || t == tok_gt || t == tok_leq || t == tok_geq || t == tok_neq || t == tok_spaceship ||
- t == tok_lshift || t == tok_rshift || t == tok_rshiftC || t == tok_rshiftR ||
- t == tok_mul || t == tok_div || t == tok_mod || t == tok_divC || t == tok_divR) {
- Expr* res = process_expr(v->get_lhs(), code);
- res->chk_rvalue();
- SymDef* sym = lookup_symbol(calc_sym_idx("_" + operator_name + "_"));
- Expr* x = process_expr(v->get_rhs(), code);
- x->chk_rvalue();
- res = create_expr_apply(v->loc, sym, {res, x});
- return res;
+ if (const auto* fun_ref = sym->try_as<FunctionData>()) {
+ std::vector<var_idx_t> rvect = {code.create_tmp_var(fun_ref->inferred_full_type, loc)};
+ code.emplace_back(loc, Op::_GlobVar, rvect, std::vector<var_idx_t>{}, fun_ref);
+ return rvect;
}
- if (t == tok_logical_and || t == tok_logical_or) {
- // do the following transformations:
- // a && b -> a ? (b != 0) : 0
- // a || b -> a ? 1 : (b != 0)
- SymDef* sym_neq = lookup_symbol(calc_sym_idx("_!=_"));
- Expr* lhs = process_expr(v->get_lhs(), code);
- Expr* rhs = process_expr(v->get_rhs(), code);
- Expr* e_neq0 = create_expr_apply(v->loc, sym_neq, {rhs, create_expr_int_const(v->loc, 0)});
- Expr* e_when_true = t == tok_logical_and ? e_neq0 : create_expr_int_const(v->loc, -1);
- Expr* e_when_false = t == tok_logical_and ? create_expr_int_const(v->loc, 0) : e_neq0;
- Expr* e_ternary = new Expr(Expr::_CondExpr, {lhs, e_when_true, e_when_false});
- e_ternary->here = v->loc;
- e_ternary->flags = Expr::_IsRvalue;
- e_ternary->deduce_type();
- return e_ternary;
+ if (const auto* var_ref = sym->try_as<LocalVarData>()) {
+ return {var_ref->idx};
}
-
- v->error("unsupported binary operator");
+ throw Fatal("process_symbol");
}
-static Expr* process_expr(V<ast_unary_operator> v, CodeBlob& code) {
- TokenType t = v->tok;
- SymDef* sym = lookup_symbol(calc_sym_idx(static_cast<std::string>(v->operator_name) + "_"));
- Expr* x = process_expr(v->get_rhs(), code);
- x->chk_rvalue();
-
- // here's an optimization to convert "-1" (tok_minus tok_int_const) to a const -1, not to Expr::Apply(-,1)
- // without this, everything still works, but Tolk looses some vars/stack knowledge for now (to be fixed later)
- // in FunC, it was:
- // `var fst = -1;` // is constantly 1
- // `var snd = - 1;` // is Expr::Apply(-), a comment "snd=1" is lost in stack layout comments, and so on
- // hence, when after grammar modification tok_minus became a true unary operator (not a part of a number),
- // and thus to preserve existing behavior until compiler parts are completely rewritten, handle this case here
- if (t == tok_minus && x->cls == Expr::_Const) {
- x->intval = -x->intval;
- if (!x->intval->signed_fits_bits(257)) {
- v->error("integer overflow");
- }
- return x;
- }
- if (t == tok_plus && x->cls == Expr::_Const) {
- return x;
+static std::vector<var_idx_t> process_assign(V<ast_assign> v, CodeBlob& code) {
+ if (auto lhs_decl = v->get_lhs()->try_as<ast_local_vars_declaration>()) {
+ return pre_compile_let(code, lhs_decl->get_expr(), v->get_rhs(), v->loc);
+ } else {
+ return pre_compile_let(code, v->get_lhs(), v->get_rhs(), v->loc);
}
-
- return create_expr_apply(v->loc, sym, {x});
}
-static Expr* process_expr(V<ast_ternary_operator> v, CodeBlob& code) {
- Expr* cond = process_expr(v->get_cond(), code);
- cond->chk_rvalue();
- Expr* x = process_expr(v->get_when_true(), code);
- x->chk_rvalue();
- Expr* y = process_expr(v->get_when_false(), code);
- y->chk_rvalue();
- Expr* res = new Expr{Expr::_CondExpr, {cond, x, y}};
- res->here = v->loc;
- res->flags = Expr::_IsRvalue;
- res->deduce_type();
- return res;
+static std::vector<var_idx_t> process_set_assign(V<ast_set_assign> v, CodeBlob& code) {
+ // for "a += b", emulate "a = a + b"
+ // seems not beautiful, but it works; probably, this transformation should be done at AST level in advance
+ std::string_view calc_operator = v->operator_name; // "+" for operator +=
+ auto v_apply = createV<ast_binary_operator>(v->loc, calc_operator, static_cast<TokenType>(v->tok - 1), v->get_lhs(), v->get_rhs());
+ v_apply->assign_inferred_type(v->inferred_type);
+ v_apply->assign_fun_ref(v->fun_ref);
+ return pre_compile_let(code, v->get_lhs(), v_apply, v->loc);
}
-static Expr* process_function_arguments(SymDef* func_sym, V<ast_argument_list> v, Expr* lhs_of_dot_call, CodeBlob& code) {
- SymValFunc* func_val = dynamic_cast<SymValFunc*>(func_sym->value);
- int delta_self = lhs_of_dot_call ? 1 : 0;
- int n_arguments = static_cast<int>(v->get_arguments().size()) + delta_self;
- int n_parameters = static_cast<int>(func_val->parameters.size());
-
- // Tolk doesn't have optional parameters currently, so just compare counts
- if (n_parameters < n_arguments) {
- v->error("too many arguments in call to `" + func_sym->name() + "`, expected " + std::to_string(n_parameters - delta_self) + ", have " + std::to_string(n_arguments - delta_self));
- }
- if (n_arguments < n_parameters) {
- v->error("too few arguments in call to `" + func_sym->name() + "`, expected " + std::to_string(n_parameters - delta_self) + ", have " + std::to_string(n_arguments - delta_self));
- }
-
- std::vector<Expr*> apply_args;
- apply_args.reserve(n_arguments);
- if (lhs_of_dot_call) {
- apply_args.push_back(lhs_of_dot_call);
- }
- for (int i = delta_self; i < n_arguments; ++i) {
- auto v_arg = v->get_arg(i - delta_self);
- if (SymDef* param_sym = func_val->parameters[i]) { // can be null (for underscore parameter)
- SymValVariable* param_val = dynamic_cast<SymValVariable*>(param_sym->value);
- if (param_val->is_mutate_parameter() != v_arg->passed_as_mutate) {
- fire_error_invalid_mutate_arg_passed(v_arg->loc, func_sym, param_sym, false, v_arg->passed_as_mutate, v_arg->get_expr());
- }
- }
-
- Expr* arg = process_expr(v_arg->get_expr(), code);
- arg->chk_rvalue();
- apply_args.push_back(arg);
- }
-
- Expr* apply = new Expr{Expr::_Apply, func_sym, std::move(apply_args)};
- apply->flags = Expr::_IsRvalue | (!func_val->is_marked_as_pure() * Expr::_IsImpure);
- apply->here = v->loc;
- apply->deduce_type();
-
- return apply;
-}
+static std::vector<var_idx_t> process_binary_operator(V<ast_binary_operator> v, CodeBlob& code) {
+ TokenType t = v->tok;
-static Expr* process_function_call(V<ast_function_call> v, CodeBlob& code) {
- // special error for "null()" which is a FunC syntax
- if (v->get_called_f()->type == ast_null_keyword) {
- v->error("null is not a function: use `null`, not `null()`");
+ if (v->fun_ref) { // almost all operators, fun_ref was assigned at type inferring
+ std::vector<var_idx_t> args_vars = pre_compile_tensor(code, {v->get_lhs(), v->get_rhs()});
+ return gen_op_call(code, v->inferred_type, v->loc, std::move(args_vars), v->fun_ref);
}
-
- // most likely it's a global function, but also may be `some_var(args)` or even `getF()(args)`
- Expr* lhs = process_expr(v->get_called_f(), code);
- if (lhs->cls != Expr::_GlobFunc) {
- Expr* tensor_arg = new Expr(Expr::_Tensor, v->loc);
- std::vector<TypeExpr*> type_list;
- type_list.reserve(v->get_num_args());
+ if (t == tok_logical_and || t == tok_logical_or) {
+ // do the following transformations:
+ // a && b -> a ? (b != 0) : 0
+ // a || b -> a ? 1 : (b != 0)
+ AnyExprV v_0 = createV<ast_int_const>(v->loc, td::make_refint(0), "0");
+ v_0->mutate()->assign_inferred_type(TypeDataInt::create());
+ AnyExprV v_1 = createV<ast_int_const>(v->loc, td::make_refint(-1), "-1");
+ v_1->mutate()->assign_inferred_type(TypeDataInt::create());
+ auto v_b_ne_0 = createV<ast_binary_operator>(v->loc, "!=", tok_neq, v->get_rhs(), v_0);
+ v_b_ne_0->mutate()->assign_inferred_type(TypeDataInt::create());
+ v_b_ne_0->mutate()->assign_fun_ref(lookup_global_symbol("_!=_")->as<FunctionData>());
+ std::vector<var_idx_t> cond = pre_compile_expr(v->get_lhs(), code);
+ tolk_assert(cond.size() == 1);
+ std::vector<var_idx_t> rvect = {code.create_tmp_var(v->inferred_type, v->loc)};
+ Op& if_op = code.emplace_back(v->loc, Op::_If, cond);
+ code.push_set_cur(if_op.block0);
+ code.emplace_back(v->loc, Op::_Let, rvect, pre_compile_expr(t == tok_logical_and ? v_b_ne_0 : v_1, code));
+ code.close_pop_cur(v->loc);
+ code.push_set_cur(if_op.block1);
+ code.emplace_back(v->loc, Op::_Let, rvect, pre_compile_expr(t == tok_logical_and ? v_0 : v_b_ne_0, code));
+ code.close_pop_cur(v->loc);
+ return rvect;
+ }
+
+ throw UnexpectedASTNodeType(v, "process_binary_operator");
+}
+
+static std::vector<var_idx_t> process_unary_operator(V<ast_unary_operator> v, CodeBlob& code) {
+ std::vector<var_idx_t> args_vars = pre_compile_tensor(code, {v->get_rhs()});
+ return gen_op_call(code, v->inferred_type, v->loc, std::move(args_vars), v->fun_ref);
+}
+
+static std::vector<var_idx_t> process_ternary_operator(V<ast_ternary_operator> v, CodeBlob& code) {
+ std::vector<var_idx_t> cond = pre_compile_expr(v->get_cond(), code);
+ tolk_assert(cond.size() == 1);
+ std::vector<var_idx_t> rvect = {code.create_tmp_var(v->inferred_type, v->loc)};
+ Op& if_op = code.emplace_back(v->loc, Op::_If, cond);
+ code.push_set_cur(if_op.block0);
+ code.emplace_back(v->get_when_true()->loc, Op::_Let, rvect, pre_compile_expr(v->get_when_true(), code));
+ code.close_pop_cur(v->get_when_true()->loc);
+ code.push_set_cur(if_op.block1);
+ code.emplace_back(v->get_when_false()->loc, Op::_Let, rvect, pre_compile_expr(v->get_when_false(), code));
+ code.close_pop_cur(v->get_when_false()->loc);
+ return rvect;
+}
+
+static std::vector<var_idx_t> process_dot_access(V<ast_dot_access> v, CodeBlob& code, LValGlobs* lval_globs) {
+ // it's NOT a method call `t.tupleSize()` (since such cases are handled by process_function_call)
+ // it's `t.0`, `getUser().id`, and `t.tupleSize` (as a reference, not as a call)
+ // currently, nothing except a global function can be a target of dot access
+ const FunctionData* fun_ref = v->target;
+ tolk_assert(fun_ref);
+ return process_symbol(v->loc, fun_ref, code, lval_globs);
+}
+
+static std::vector<var_idx_t> process_function_call(V<ast_function_call> v, CodeBlob& code) {
+ // v is `globalF(args)` / `globalF<int>(args)` / `obj.method(args)` / `local_var(args)` / `getF()(args)`
+ const FunctionData* fun_ref = v->fun_maybe;
+ if (!fun_ref) {
+ std::vector<AnyExprV> args;
+ args.reserve(v->get_num_args());
for (int i = 0; i < v->get_num_args(); ++i) {
- auto v_arg = v->get_arg(i);
- if (v_arg->passed_as_mutate) {
- v_arg->error("`mutate` used for non-mutate argument");
+ args.push_back(v->get_arg(i)->get_expr());
+ }
+ std::vector<var_idx_t> args_vars = pre_compile_tensor(code, args);
+ std::vector<var_idx_t> tfunc = pre_compile_expr(v->get_callee(), code);
+ tolk_assert(tfunc.size() == 1);
+ args_vars.push_back(tfunc[0]);
+ std::vector<var_idx_t> rvect = {code.create_tmp_var(v->inferred_type, v->loc)};
+ Op& op = code.emplace_back(v->loc, Op::_CallInd, rvect, std::move(args_vars));
+ op.set_impure_flag();
+ return rvect;
+ }
+
+ int delta_self = v->is_dot_call();
+ AnyExprV obj_leftmost = nullptr;
+ std::vector<AnyExprV> args;
+ args.reserve(delta_self + v->get_num_args());
+ if (delta_self) {
+ args.push_back(v->get_dot_obj());
+ obj_leftmost = v->get_dot_obj();
+ while (obj_leftmost->type == ast_function_call && obj_leftmost->as<ast_function_call>()->is_dot_call() && obj_leftmost->as<ast_function_call>()->fun_maybe && obj_leftmost->as<ast_function_call>()->fun_maybe->does_return_self()) {
+ obj_leftmost = obj_leftmost->as<ast_function_call>()->get_dot_obj();
+ }
+ }
+ for (int i = 0; i < v->get_num_args(); ++i) {
+ args.push_back(v->get_arg(i)->get_expr());
+ }
+ std::vector<std::vector<var_idx_t>> vars_per_arg = pre_compile_tensor_inner(code, args, nullptr);
+
+ TypePtr op_call_type = v->inferred_type;
+ TypePtr real_ret_type = v->inferred_type;
+ if (delta_self && fun_ref->does_return_self()) {
+ real_ret_type = TypeDataVoid::create();
+ if (!fun_ref->parameters[0].is_mutate_parameter()) {
+ op_call_type = TypeDataVoid::create();
+ }
+ }
+ if (fun_ref->has_mutate_params()) {
+ std::vector<TypePtr> types_list;
+ for (int i = 0; i < delta_self + v->get_num_args(); ++i) {
+ if (fun_ref->parameters[i].is_mutate_parameter()) {
+ types_list.push_back(args[i]->inferred_type);
}
- Expr* arg = process_expr(v_arg->get_expr(), code);
- arg->chk_rvalue();
- tensor_arg->pb_arg(arg);
- type_list.push_back(arg->e_type);
}
- tensor_arg->flags = Expr::_IsRvalue;
- tensor_arg->e_type = TypeExpr::new_tensor(std::move(type_list));
-
- Expr* var_apply = new Expr{Expr::_VarApply, {lhs, tensor_arg}};
- var_apply->here = v->loc;
- var_apply->flags = Expr::_IsRvalue;
- var_apply->deduce_type();
- return var_apply;
+ types_list.push_back(real_ret_type);
+ op_call_type = TypeDataTensor::create(std::move(types_list));
}
- Expr* apply = process_function_arguments(lhs->sym, v->get_arg_list(), nullptr, code);
-
- if (dynamic_cast<SymValFunc*>(apply->sym->value)->has_mutate_params()) {
- const std::vector<Expr*>& args = apply->args;
- SymValFunc* func_val = dynamic_cast<SymValFunc*>(apply->sym->value);
- tolk_assert(func_val->parameters.size() == args.size());
- Expr* grabbed_vars = new Expr(Expr::_Tensor, v->loc);
- std::vector<TypeExpr*> type_list;
- for (int i = 0; i < static_cast<int>(args.size()); ++i) {
- SymDef* param_def = func_val->parameters[i];
- if (param_def && dynamic_cast<SymValVariable*>(param_def->value)->is_mutate_parameter()) {
- if (!args[i]->is_lvalue()) {
- args[i]->fire_error_lvalue_expected("call a mutating function");
- }
- if (args[i]->is_immutable()) {
- args[i]->fire_error_modifying_immutable("call a mutating function");
- }
- grabbed_vars->pb_arg(args[i]->copy());
- type_list.emplace_back(args[i]->e_type);
- }
- }
- grabbed_vars->flags = Expr::_IsRvalue;
- Expr* grab_mutate = new Expr(Expr::_GrabMutatedVars, apply->sym, {apply, grabbed_vars});
- grab_mutate->here = v->loc;
- grab_mutate->flags = apply->flags;
- grab_mutate->deduce_type();
- return grab_mutate;
+ std::vector<var_idx_t> args_vars;
+ for (const std::vector<var_idx_t>& list : vars_per_arg) {
+ args_vars.insert(args_vars.end(), list.cbegin(), list.cend());
}
+ std::vector<var_idx_t> rvect_apply = gen_op_call(code, op_call_type, v->loc, std::move(args_vars), fun_ref);
- return apply;
-}
-
-static Expr* process_dot_method_call(V<ast_dot_method_call> v, CodeBlob& code) {
- sym_idx_t name_idx = calc_sym_idx(v->method_name);
- check_global_func(v->loc, name_idx);
- SymDef* func_sym = lookup_symbol(name_idx);
- SymValFunc* func_val = dynamic_cast<SymValFunc*>(func_sym->value);
- tolk_assert(func_val != nullptr);
-
- Expr* obj = process_expr(v->get_obj(), code);
- obj->chk_rvalue();
-
- if (func_val->parameters.empty()) {
- v->error("`" + func_sym->name() + "` has no parameters and can not be called as method");
- }
- if (!func_val->does_accept_self() && func_val->parameters[0] && dynamic_cast<SymValVariable*>(func_val->parameters[0]->value)->is_mutate_parameter()) {
- fire_error_invalid_mutate_arg_passed(v->loc, func_sym, func_val->parameters[0], true, false, v->get_obj());
- }
-
- Expr* apply = process_function_arguments(func_sym, v->get_arg_list(), obj, code);
-
- Expr* obj_lval = apply->args[0];
- if (!obj_lval->is_lvalue()) {
- if (obj_lval->cls == Expr::_ReturnSelf) {
- obj_lval = obj_lval->args[1];
- } else {
- Expr* tmp_var = create_new_underscore_variable(v->loc, obj_lval->e_type);
- tmp_var->define_new_vars(code);
- Expr* assign_to_tmp_var = new Expr(Expr::_Letop, {tmp_var, obj_lval});
- assign_to_tmp_var->here = v->loc;
- assign_to_tmp_var->flags = Expr::_IsRvalue;
- assign_to_tmp_var->deduce_type();
- apply->args[0] = assign_to_tmp_var;
- obj_lval = tmp_var;
- }
- }
-
- if (func_val->has_mutate_params()) {
- tolk_assert(func_val->parameters.size() == apply->args.size());
- Expr* grabbed_vars = new Expr(Expr::_Tensor, v->loc);
- std::vector<TypeExpr*> type_list;
- for (int i = 0; i < static_cast<int>(apply->args.size()); ++i) {
- SymDef* param_sym = func_val->parameters[i];
- if (param_sym && dynamic_cast<SymValVariable*>(param_sym->value)->is_mutate_parameter()) {
- Expr* ith_arg = apply->args[i];
- if (ith_arg->is_immutable()) {
- ith_arg->fire_error_modifying_immutable("call a mutating method");
- }
-
- Expr* var_to_mutate = nullptr;
- if (ith_arg->is_lvalue()) {
- var_to_mutate = ith_arg->copy();
- } else if (i == 0) {
- var_to_mutate = obj_lval;
+ if (fun_ref->has_mutate_params()) {
+ LValGlobs local_globs;
+ std::vector<var_idx_t> left;
+ for (int i = 0; i < delta_self + v->get_num_args(); ++i) {
+ if (fun_ref->parameters[i].is_mutate_parameter()) {
+ AnyExprV arg_i = obj_leftmost && i == 0 ? obj_leftmost : args[i];
+ tolk_assert(arg_i->is_lvalue || i == 0);
+ if (arg_i->is_lvalue) {
+ std::vector<var_idx_t> ith_var_idx = pre_compile_expr(arg_i, code, &local_globs);
+ left.insert(left.end(), ith_var_idx.begin(), ith_var_idx.end());
} else {
- ith_arg->fire_error_lvalue_expected("call a mutating method");
+ left.insert(left.end(), vars_per_arg[0].begin(), vars_per_arg[0].end());
}
- tolk_assert(var_to_mutate->is_lvalue() && !var_to_mutate->is_immutable());
- grabbed_vars->pb_arg(var_to_mutate);
- type_list.emplace_back(var_to_mutate->e_type);
}
}
- grabbed_vars->flags = Expr::_IsRvalue;
-
- Expr* grab_mutate = new Expr(Expr::_GrabMutatedVars, func_sym, {apply, grabbed_vars});
- grab_mutate->here = v->loc;
- grab_mutate->flags = apply->flags;
- grab_mutate->deduce_type();
-
- apply = grab_mutate;
+ std::vector<var_idx_t> rvect = {code.create_tmp_var(real_ret_type, v->loc)};
+ left.push_back(rvect[0]);
+ code.on_var_modification(left, v->loc);
+ code.emplace_back(v->loc, Op::_Let, std::move(left), rvect_apply);
+ local_globs.gen_ops_set_globs(code, v->loc);
+ rvect_apply = rvect;
}
- if (func_val->does_return_self()) {
- Expr* self_arg = obj_lval;
- tolk_assert(self_arg->is_lvalue());
-
- Expr* return_self = new Expr(Expr::_ReturnSelf, func_sym, {apply, self_arg});
- return_self->here = v->loc;
- return_self->flags = Expr::_IsRvalue;
- return_self->deduce_type();
-
- apply = return_self;
+ if (obj_leftmost && fun_ref->does_return_self()) {
+ if (obj_leftmost->is_lvalue) { // to handle if obj is global var, potentially re-assigned inside a chain
+ rvect_apply = pre_compile_expr(obj_leftmost, code);
+ } else { // temporary object, not lvalue, pre_compile_expr
+ rvect_apply = vars_per_arg[0];
+ }
}
- return apply;
+ return rvect_apply;
}
-static Expr* process_expr(V<ast_tensor> v, CodeBlob& code) {
- if (v->empty()) {
- Expr* res = new Expr{Expr::_Tensor, {}};
- res->flags = Expr::_IsRvalue;
- res->here = v->loc;
- res->e_type = TypeExpr::new_unit();
- return res;
- }
-
- Expr* res = process_expr(v->get_item(0), code);
- std::vector<TypeExpr*> type_list;
- type_list.push_back(res->e_type);
- int f = res->flags;
- res = new Expr{Expr::_Tensor, {res}};
- for (int i = 1; i < v->size(); ++i) {
- Expr* x = process_expr(v->get_item(i), code);
- res->pb_arg(x);
- f &= (x->flags | Expr::_IsImmutable);
- f |= (x->flags & Expr::_IsImmutable);
- type_list.push_back(x->e_type);
- }
- res->here = v->loc;
- res->flags = f;
- res->e_type = TypeExpr::new_tensor(std::move(type_list));
- return res;
+static std::vector<var_idx_t> process_tensor(V<ast_tensor> v, CodeBlob& code, LValGlobs* lval_globs) {
+ return pre_compile_tensor(code, v->get_items(), lval_globs);
}
-static Expr* process_expr(V<ast_tensor_square> v, CodeBlob& code) {
- if (v->empty()) {
- Expr* res = new Expr{Expr::_Tensor, {}};
- res->flags = Expr::_IsRvalue;
- res->here = v->loc;
- res->e_type = TypeExpr::new_unit();
- res = new Expr{Expr::_MkTuple, {res}};
- res->flags = Expr::_IsRvalue;
- res->here = v->loc;
- res->e_type = TypeExpr::new_tuple(res->args.at(0)->e_type);
- return res;
- }
-
- Expr* res = process_expr(v->get_item(0), code);
- std::vector<TypeExpr*> type_list;
- type_list.push_back(res->e_type);
- int f = res->flags;
- res = new Expr{Expr::_Tensor, {res}};
- for (int i = 1; i < v->size(); ++i) {
- Expr* x = process_expr(v->get_item(i), code);
- res->pb_arg(x);
- f &= (x->flags | Expr::_IsImmutable);
- f |= (x->flags & Expr::_IsImmutable);
- type_list.push_back(x->e_type);
+static std::vector<var_idx_t> process_typed_tuple(V<ast_typed_tuple> v, CodeBlob& code, LValGlobs* lval_globs) {
+ if (lval_globs) { // todo some time, make "var (a, [b,c]) = (1, [2,3])" work
+ v->error("[...] can not be used as lvalue here");
}
- res->here = v->loc;
- res->flags = f;
- res->e_type = TypeExpr::new_tensor(std::move(type_list), false);
- res = new Expr{Expr::_MkTuple, {res}};
- res->flags = f;
- res->here = v->loc;
- res->e_type = TypeExpr::new_tuple(res->args.at(0)->e_type);
- return res;
+ std::vector<var_idx_t> left = std::vector{code.create_tmp_var(v->inferred_type, v->loc)};
+ std::vector<var_idx_t> right = pre_compile_tensor(code, v->get_items());
+ code.emplace_back(v->loc, Op::_Tuple, left, std::move(right));
+ return left;
}
-static Expr* process_expr(V<ast_int_const> v) {
- Expr* res = new Expr{Expr::_Const, v->loc};
- res->flags = Expr::_IsRvalue;
- res->intval = td::string_to_int256(static_cast<std::string>(v->int_val));
- if (res->intval.is_null() || !res->intval->signed_fits_bits(257)) {
- v->error("invalid integer constant");
- }
- res->e_type = TypeExpr::new_atomic(TypeExpr::_Int);
- return res;
+static std::vector<var_idx_t> process_int_const(V<ast_int_const> v, CodeBlob& code) {
+ std::vector<var_idx_t> rvect = {code.create_tmp_var(v->inferred_type, v->loc)};
+ code.emplace_back(v->loc, Op::_IntConst, rvect, v->intval);
+ return rvect;
}
-static Expr* process_expr(V<ast_string_const> v) {
- std::string str = static_cast<std::string>(v->str_val);
- Expr* res;
- switch (v->modifier) {
- case 0:
- case 's':
- case 'a':
- res = new Expr{Expr::_SliceConst, v->loc};
- res->e_type = TypeExpr::new_atomic(TypeExpr::_Slice);
- break;
- case 'u':
- case 'h':
- case 'H':
- case 'c':
- res = new Expr{Expr::_Const, v->loc};
- res->e_type = TypeExpr::new_atomic(TypeExpr::_Int);
- break;
- default:
- v->error("invalid string modifier '" + std::string(1, v->modifier) + "'");
- }
- res->flags = Expr::_IsRvalue;
- switch (v->modifier) {
- case 0: {
- res->strval = td::hex_encode(str);
- break;
- }
- case 's': {
- res->strval = str;
- unsigned char buff[128];
- int bits = (int)td::bitstring::parse_bitstring_hex_literal(buff, sizeof(buff), str.data(), str.data() + str.size());
- if (bits < 0) {
- v->error("invalid hex bitstring constant '" + str + "'");
- }
- break;
- }
- case 'a': { // MsgAddress
- int workchain;
- ton::StdSmcAddress addr;
- bool correct = (str.size() == 48 && parse_friendly_address(str.data(), workchain, addr)) ||
- (str.size() != 48 && parse_raw_address(str, workchain, addr));
- if (!correct) {
- v->error("invalid standard address '" + str + "'");
- }
- if (workchain < -128 || workchain >= 128) {
- v->error("anycast addresses not supported");
- }
-
- unsigned char data[3 + 8 + 256]; // addr_std$10 anycast:(Maybe Anycast) workchain_id:int8 address:bits256 = MsgAddressInt;
- td::bitstring::bits_store_long_top(data, 0, static_cast<uint64_t>(4) << (64 - 3), 3);
- td::bitstring::bits_store_long_top(data, 3, static_cast<uint64_t>(workchain) << (64 - 8), 8);
- td::bitstring::bits_memcpy(data, 3 + 8, addr.bits().ptr, 0, addr.size());
- res->strval = td::BitSlice{data, sizeof(data)}.to_hex();
- break;
- }
- case 'u': {
- res->intval = td::hex_string_to_int256(td::hex_encode(str));
- if (str.empty()) {
- v->error("empty integer ascii-constant");
- }
- if (res->intval.is_null()) {
- v->error("too long integer ascii-constant");
- }
- break;
- }
- case 'h':
- case 'H': {
- unsigned char hash[32];
- digest::hash_str<digest::SHA256>(hash, str.data(), str.size());
- res->intval = td::bits_to_refint(hash, (v->modifier == 'h') ? 32 : 256, false);
- break;
- }
- case 'c': {
- res->intval = td::make_refint(td::crc32(td::Slice{str}));
- break;
- }
- default:
- tolk_assert(false);
+static std::vector<var_idx_t> process_string_const(V<ast_string_const> v, CodeBlob& code) {
+ ConstantValue value = eval_const_init_value(v);
+ std::vector<var_idx_t> rvect = {code.create_tmp_var(v->inferred_type, v->loc)};
+ if (value.is_int()) {
+ code.emplace_back(v->loc, Op::_IntConst, rvect, value.as_int());
+ } else {
+ code.emplace_back(v->loc, Op::_SliceConst, rvect, value.as_slice());
}
- return res;
+ return rvect;
}
-static Expr* process_expr(V<ast_bool_const> v) {
- SymDef* builtin_sym = lookup_symbol(calc_sym_idx(v->bool_val ? "__true" : "__false"));
- return create_expr_apply(v->loc, builtin_sym, {});
+static std::vector<var_idx_t> process_bool_const(V<ast_bool_const> v, CodeBlob& code) {
+ const FunctionData* builtin_sym = lookup_global_symbol(v->bool_val ? "__true" : "__false")->as<FunctionData>();
+ return gen_op_call(code, v->inferred_type, v->loc, {}, builtin_sym);
}
-static Expr* process_expr(V<ast_null_keyword> v) {
- SymDef* builtin_sym = lookup_symbol(calc_sym_idx("__null"));
- return create_expr_apply(v->loc, builtin_sym, {});
+static std::vector<var_idx_t> process_null_keyword(V<ast_null_keyword> v, CodeBlob& code) {
+ const FunctionData* builtin_sym = lookup_global_symbol("__null")->as<FunctionData>();
+ return gen_op_call(code, v->inferred_type, v->loc, {}, builtin_sym);
}
-static Expr* process_expr(V<ast_self_keyword> v, CodeBlob& code) {
- if (!code.func_val->does_accept_self()) {
- v->error("using `self` in a non-member function (it does not accept the first `self` parameter)");
+static std::vector<var_idx_t> process_local_var(V<ast_local_var_lhs> v, CodeBlob& code) {
+ if (v->marked_as_redef) {
+ return process_symbol(v->loc, v->var_ref, code, nullptr);
}
- SymDef* sym = lookup_symbol(calc_sym_idx("self"));
- tolk_assert(sym);
- SymValVariable* sym_val = dynamic_cast<SymValVariable*>(sym->value);
- Expr* res = new Expr(Expr::_Var, v->loc);
- res->sym = sym;
- res->val = sym_val->idx;
- res->flags = Expr::_IsLvalue | Expr::_IsRvalue | (sym_val->is_immutable() ? Expr::_IsImmutable : 0);
- res->e_type = sym_val->get_type();
- return res;
+
+ tolk_assert(v->var_ref->idx == -1);
+ v->var_ref->mutate()->assign_idx(code.create_var(v->inferred_type, v->var_ref, v->loc));
+ return {v->var_ref->idx};
}
-static Expr* process_identifier(V<ast_identifier> v) {
- SymDef* sym = lookup_symbol(calc_sym_idx(v->name));
- if (sym && dynamic_cast<SymValGlobVar*>(sym->value)) {
- check_import_exists_when_using_sym(v, sym);
- Expr* res = new Expr{Expr::_GlobVar, v->loc};
- res->e_type = sym->value->get_type();
- res->sym = sym;
- res->flags = Expr::_IsLvalue | Expr::_IsRvalue | Expr::_IsImpure;
- return res;
- }
- if (sym && dynamic_cast<SymValConst*>(sym->value)) {
- check_import_exists_when_using_sym(v, sym);
- auto val = dynamic_cast<SymValConst*>(sym->value);
- Expr* res = nullptr;
- if (val->get_kind() == SymValConst::IntConst) {
- res = new Expr{Expr::_Const, v->loc};
- res->intval = val->get_int_value();
- res->e_type = TypeExpr::new_atomic(TypeExpr::_Int);
- } else if (val->get_kind() == SymValConst::SliceConst) {
- res = new Expr{Expr::_SliceConst, v->loc};
- res->strval = val->get_str_value();
- res->e_type = TypeExpr::new_atomic(TypeExpr::_Slice);
- } else {
- v->error("invalid symbolic constant type");
- }
- res->flags = Expr::_IsLvalue | Expr::_IsRvalue | Expr::_IsImmutable;
- res->sym = sym;
- return res;
- }
- if (sym && dynamic_cast<SymValFunc*>(sym->value)) {
- check_import_exists_when_using_sym(v, sym);
- }
- Expr* res = new Expr{Expr::_Var, v->loc};
- if (!sym) {
- check_global_func(v->loc, calc_sym_idx(v->name));
- sym = lookup_symbol(calc_sym_idx(v->name));
- tolk_assert(sym);
- }
- res->sym = sym;
- bool impure = false;
- bool immutable = false;
- if (const SymValFunc* func_val = dynamic_cast<SymValFunc*>(sym->value)) {
- res->e_type = func_val->get_type();
- res->cls = Expr::_GlobFunc;
- impure = !func_val->is_marked_as_pure();
- } else if (const SymValVariable* var_val = dynamic_cast<SymValVariable*>(sym->value)) {
- tolk_assert(var_val->idx >= 0)
- res->val = var_val->idx;
- res->e_type = var_val->get_type();
- immutable = var_val->is_immutable();
- // std::cerr << "accessing variable " << lex.cur().str << " : " << res->e_type << std::endl;
- } else {
- v->error("undefined identifier '" + static_cast<std::string>(v->name) + "'");
- }
- // std::cerr << "accessing symbol " << lex.cur().str << " : " << res->e_type << (val->impure ? " (impure)" : " (pure)") << std::endl;
- res->flags = Expr::_IsLvalue | Expr::_IsRvalue | (impure ? Expr::_IsImpure : 0) | (immutable ? Expr::_IsImmutable : 0);
- res->deduce_type();
- return res;
+static std::vector<var_idx_t> process_local_vars_declaration(V<ast_local_vars_declaration>, CodeBlob&) {
+ // it can not appear as a standalone expression
+ // `var ... = rhs` is handled by ast_assign
+ tolk_assert(false);
}
-Expr* process_expr(AnyV v, CodeBlob& code) {
+static std::vector<var_idx_t> process_underscore(V<ast_underscore> v, CodeBlob& code) {
+ // when _ is used as left side of assignment, like `(cs, _) = cs.loadAndReturn()`
+ return {code.create_tmp_var(v->inferred_type, v->loc)};
+}
+
+std::vector<var_idx_t> pre_compile_expr(AnyExprV v, CodeBlob& code, LValGlobs* lval_globs) {
switch (v->type) {
+ case ast_reference:
+ return process_symbol(v->loc, v->as<ast_reference>()->sym, code, lval_globs);
+ case ast_assign:
+ return process_assign(v->as<ast_assign>(), code);
+ case ast_set_assign:
+ return process_set_assign(v->as<ast_set_assign>(), code);
case ast_binary_operator:
- return process_expr(v->as<ast_binary_operator>(), code);
+ return process_binary_operator(v->as<ast_binary_operator>(), code);
case ast_unary_operator:
- return process_expr(v->as<ast_unary_operator>(), code);
+ return process_unary_operator(v->as<ast_unary_operator>(), code);
case ast_ternary_operator:
- return process_expr(v->as<ast_ternary_operator>(), code);
+ return process_ternary_operator(v->as<ast_ternary_operator>(), code);
+ case ast_cast_as_operator:
+ return pre_compile_expr(v->as<ast_cast_as_operator>()->get_expr(), code, lval_globs);
+ case ast_dot_access:
+ return process_dot_access(v->as<ast_dot_access>(), code, lval_globs);
case ast_function_call:
return process_function_call(v->as<ast_function_call>(), code);
- case ast_dot_method_call:
- return process_dot_method_call(v->as<ast_dot_method_call>(), code);
- case ast_parenthesized_expr:
- return process_expr(v->as<ast_parenthesized_expr>()->get_expr(), code);
+ case ast_parenthesized_expression:
+ return pre_compile_expr(v->as<ast_parenthesized_expression>()->get_expr(), code, lval_globs);
case ast_tensor:
- return process_expr(v->as<ast_tensor>(), code);
- case ast_tensor_square:
- return process_expr(v->as<ast_tensor_square>(), code);
+ return process_tensor(v->as<ast_tensor>(), code, lval_globs);
+ case ast_typed_tuple:
+ return process_typed_tuple(v->as<ast_typed_tuple>(), code, lval_globs);
case ast_int_const:
- return process_expr(v->as<ast_int_const>());
+ return process_int_const(v->as<ast_int_const>(), code);
case ast_string_const:
- return process_expr(v->as<ast_string_const>());
+ return process_string_const(v->as<ast_string_const>(), code);
case ast_bool_const:
- return process_expr(v->as<ast_bool_const>());
+ return process_bool_const(v->as<ast_bool_const>(), code);
case ast_null_keyword:
- return process_expr(v->as<ast_null_keyword>());
- case ast_self_keyword:
- return process_expr(v->as<ast_self_keyword>(), code);
- case ast_identifier:
- return process_identifier(v->as<ast_identifier>());
+ return process_null_keyword(v->as<ast_null_keyword>(), code);
+ case ast_local_var_lhs:
+ return process_local_var(v->as<ast_local_var_lhs>(), code);
+ case ast_local_vars_declaration:
+ return process_local_vars_declaration(v->as<ast_local_vars_declaration>(), code);
case ast_underscore:
- return create_new_underscore_variable(v->loc, TypeExpr::new_hole());
+ return process_underscore(v->as<ast_underscore>(), code);
default:
- throw UnexpectedASTNodeType(v, "process_expr");
+ throw UnexpectedASTNodeType(v, "pre_compile_expr");
}
}
-static Expr* process_local_vars_lhs(AnyV v, CodeBlob& code) {
- switch (v->type) {
- case ast_local_var: {
- auto v_var = v->as<ast_local_var>();
- if (v_var->marked_as_redef) {
- Expr* redef_var = process_identifier(v_var->get_identifier()->as<ast_identifier>());
- if (redef_var->is_immutable()) {
- redef_var->fire_error_modifying_immutable("left side of assignment");
- }
- return redef_var;
- }
- TypeExpr* var_type = v_var->declared_type ? v_var->declared_type : TypeExpr::new_hole();
- if (auto v_ident = v->as<ast_local_var>()->get_identifier()->try_as<ast_identifier>()) {
- return create_new_local_variable(v->loc, v_ident->name, var_type, v_var->is_immutable);
- } else {
- return create_new_underscore_variable(v->loc, var_type);
- }
- }
- case ast_parenthesized_expr:
- return process_local_vars_lhs(v->as<ast_parenthesized_expr>()->get_expr(), code);
- case ast_tensor: {
- std::vector<TypeExpr*> type_list;
- Expr* res = new Expr{Expr::_Tensor, v->loc};
- for (AnyV item : v->as<ast_tensor>()->get_items()) {
- Expr* x = process_local_vars_lhs(item, code);
- res->pb_arg(x);
- res->flags |= x->flags;
- type_list.push_back(x->e_type);
- }
- res->e_type = TypeExpr::new_tensor(std::move(type_list));
- return res;
- }
- case ast_tensor_square: {
- std::vector<TypeExpr*> type_list;
- Expr* res = new Expr{Expr::_Tensor, v->loc};
- for (AnyV item : v->as<ast_tensor_square>()->get_items()) {
- Expr* x = process_local_vars_lhs(item, code);
- res->pb_arg(x);
- res->flags |= x->flags;
- type_list.push_back(x->e_type);
- }
- res->e_type = TypeExpr::new_tensor(std::move(type_list));
- res = new Expr{Expr::_MkTuple, {res}};
- res->flags = res->args.at(0)->flags;
- res->here = v->loc;
- res->e_type = TypeExpr::new_tuple(res->args.at(0)->e_type);
- return res;
- }
- default:
- throw UnexpectedASTNodeType(v, "process_local_vars_lhs");
- }
-}
-
-static blk_fl::val process_vertex(V<ast_local_vars_declaration> v, CodeBlob& code) {
- Expr* x = process_local_vars_lhs(v->get_lhs(), code);
- Expr* y = process_expr(v->get_assigned_val(), code);
- y->chk_rvalue();
- x->predefine_vars();
- x->define_new_vars(code);
- Expr* res = new Expr{Expr::_Letop, {x, y}};
- res->here = v->loc;
- res->flags = x->flags | Expr::_IsRvalue;
- res->deduce_type();
- res->chk_rvalue();
- res->pre_compile(code);
- return blk_fl::end;
-}
-static bool is_expr_valid_as_return_self(Expr* return_expr) {
- // `return self`
- if (return_expr->cls == Expr::_Var && return_expr->val == 0) {
- return true;
- }
- if (return_expr->cls == Expr::_ReturnSelf) {
- return is_expr_valid_as_return_self(return_expr->args[1]);
- }
- if (return_expr->cls == Expr::_CondExpr) {
- return is_expr_valid_as_return_self(return_expr->args[1]) && is_expr_valid_as_return_self(return_expr->args[2]);
+static void process_sequence(V<ast_sequence> v, CodeBlob& code) {
+ for (AnyV item : v->get_items()) {
+ process_any_statement(item, code);
}
- return false;
}
-// for mutating functions, having `return expr`, transform it to `return (modify_var1, ..., expr)`
-static Expr* wrap_return_value_with_mutate_params(SrcLocation loc, CodeBlob& code, Expr* return_expr) {
- Expr* tmp_var;
- if (return_expr->cls != Expr::_Var) {
- // `return complex_expr` - extract this into temporary variable (eval it before return)
- // this is mandatory if it assigns to one of modified vars
- tmp_var = create_new_underscore_variable(loc, return_expr->e_type);
- tmp_var->predefine_vars();
- tmp_var->define_new_vars(code);
- Expr* assign_to_tmp_var = new Expr(Expr::_Letop, {tmp_var, return_expr});
- assign_to_tmp_var->here = loc;
- assign_to_tmp_var->flags = tmp_var->flags | Expr::_IsRvalue;
- assign_to_tmp_var->deduce_type();
- assign_to_tmp_var->pre_compile(code);
+static void process_assert_statement(V<ast_assert_statement> v, CodeBlob& code) {
+ std::vector<AnyExprV> args(3);
+ if (auto v_not = v->get_cond()->try_as<ast_unary_operator>(); v_not && v_not->tok == tok_logical_not) {
+ args[0] = v->get_thrown_code();
+ args[1] = v->get_cond()->as<ast_unary_operator>()->get_rhs();
+ args[2] = createV<ast_bool_const>(v->loc, true);
+ args[2]->mutate()->assign_inferred_type(TypeDataInt::create());
} else {
- tmp_var = return_expr;
+ args[0] = v->get_thrown_code();
+ args[1] = v->get_cond();
+ args[2] = createV<ast_bool_const>(v->loc, false);
+ args[2]->mutate()->assign_inferred_type(TypeDataInt::create());
}
- Expr* ret_tensor = new Expr(Expr::_Tensor, loc);
- std::vector<TypeExpr*> type_list;
- for (SymDef* p_sym: code.func_val->parameters) {
- if (p_sym && dynamic_cast<SymValVariable*>(p_sym->value)->is_mutate_parameter()) {
- Expr* p_expr = new Expr{Expr::_Var, p_sym->loc};
- p_expr->sym = p_sym;
- p_expr->val = p_sym->value->idx;
- p_expr->flags = Expr::_IsRvalue;
- p_expr->e_type = p_sym->value->get_type();
- ret_tensor->pb_arg(p_expr);
- type_list.emplace_back(p_expr->e_type);
- }
- }
- ret_tensor->pb_arg(tmp_var);
- type_list.emplace_back(tmp_var->e_type);
- ret_tensor->flags = Expr::_IsRvalue;
- ret_tensor->e_type = TypeExpr::new_tensor(std::move(type_list));
- return ret_tensor;
+ const FunctionData* builtin_sym = lookup_global_symbol("__throw_if_unless")->as<FunctionData>();
+ std::vector<var_idx_t> args_vars = pre_compile_tensor(code, args);
+ gen_op_call(code, TypeDataVoid::create(), v->loc, std::move(args_vars), builtin_sym);
}
-static blk_fl::val process_vertex(V<ast_return_statement> v, CodeBlob& code) {
- Expr* expr = process_expr(v->get_return_value(), code);
- if (code.func_val->does_return_self()) {
- if (!is_expr_valid_as_return_self(expr)) {
- v->error("invalid return from `self` function");
- }
- Expr* var_self = new Expr(Expr::_Var, v->loc);
- var_self->flags = Expr::_IsRvalue | Expr::_IsLvalue;
- var_self->e_type = code.func_val->parameters[0]->value->get_type();
- Expr* assign_to_self = new Expr(Expr::_Letop, {var_self, expr});
- assign_to_self->here = v->loc;
- assign_to_self->flags = Expr::_IsRvalue;
- assign_to_self->deduce_type();
- assign_to_self->pre_compile(code);
- Expr* empty_tensor = new Expr(Expr::_Tensor, {});
- empty_tensor->here = v->loc;
- empty_tensor->flags = Expr::_IsRvalue;
- empty_tensor->e_type = TypeExpr::new_tensor({});
- expr = empty_tensor;
+static void process_catch_variable(AnyExprV v_catch_var, CodeBlob& code) {
+ if (auto v_ref = v_catch_var->try_as<ast_reference>(); v_ref && v_ref->sym) { // not underscore
+ const LocalVarData* var_ref = v_ref->sym->as<LocalVarData>();
+ tolk_assert(var_ref->idx == -1);
+ var_ref->mutate()->assign_idx(code.create_var(v_catch_var->inferred_type, var_ref, v_catch_var->loc));
}
- if (code.func_val->has_mutate_params()) {
- expr = wrap_return_value_with_mutate_params(v->loc, code, expr);
- }
- expr->chk_rvalue();
- try {
- unify(expr->e_type, code.ret_type);
- } catch (UnifyError& ue) {
- std::ostringstream os;
- os << "previous function return type " << code.ret_type
- << " cannot be unified with return statement expression type " << expr->e_type << ": " << ue;
- v->error(os.str());
- }
- std::vector<var_idx_t> tmp_vars = expr->pre_compile(code);
- code.emplace_back(v->loc, Op::_Return, std::move(tmp_vars));
- return blk_fl::ret;
}
-static void append_implicit_ret_stmt(SrcLocation loc_end, CodeBlob& code) {
- Expr* expr = new Expr{Expr::_Tensor, {}};
- expr->flags = Expr::_IsRvalue;
- expr->here = loc_end;
- expr->e_type = TypeExpr::new_unit();
- if (code.func_val->does_return_self()) {
- throw ParseError(loc_end, "missing return; forgot `return self`?");
- }
- if (code.func_val->has_mutate_params()) {
- expr = wrap_return_value_with_mutate_params(loc_end, code, expr);
- }
- try {
- unify(expr->e_type, code.ret_type);
- } catch (UnifyError& ue) {
- std::ostringstream os;
- os << "previous function return type " << code.ret_type
- << " cannot be unified with implicit end-of-block return type " << expr->e_type << ": " << ue;
- throw ParseError(loc_end, os.str());
- }
- std::vector<var_idx_t> tmp_vars = expr->pre_compile(code);
- code.emplace_back(loc_end, Op::_Return, std::move(tmp_vars));
-}
+static void process_try_catch_statement(V<ast_try_catch_statement> v, CodeBlob& code) {
+ code.require_callxargs = true;
+ Op& try_catch_op = code.emplace_back(v->loc, Op::_TryCatch);
+ code.push_set_cur(try_catch_op.block0);
+ process_any_statement(v->get_try_body(), code);
+ code.close_pop_cur(v->get_try_body()->loc_end);
+ code.push_set_cur(try_catch_op.block1);
-static blk_fl::val process_vertex(V<ast_sequence> v, CodeBlob& code, bool no_new_scope = false) {
- if (!no_new_scope) {
- open_scope(v->loc);
- }
- blk_fl::val res = blk_fl::init;
- bool warned = false;
- for (AnyV item : v->get_items()) {
- if (!(res & blk_fl::end) && !warned) {
- item->loc.show_warning("unreachable code");
- warned = true;
- }
- blk_fl::combine(res, process_statement(item, code));
- }
- if (!no_new_scope) {
- close_scope();
- }
- return res;
+ // transform catch (excNo, arg) into TVM-catch (arg, excNo), where arg is untyped and thus almost useless now
+ const std::vector<AnyExprV>& catch_vars = v->get_catch_expr()->get_items();
+ tolk_assert(catch_vars.size() == 2);
+ process_catch_variable(catch_vars[0], code);
+ process_catch_variable(catch_vars[1], code);
+ try_catch_op.left = pre_compile_tensor(code, {catch_vars[1], catch_vars[0]});
+ process_any_statement(v->get_catch_body(), code);
+ code.close_pop_cur(v->get_catch_body()->loc_end);
}
-static blk_fl::val process_vertex(V<ast_repeat_statement> v, CodeBlob& code) {
- Expr* expr = process_expr(v->get_cond(), code);
- expr->chk_rvalue();
- auto cnt_type = TypeExpr::new_atomic(TypeExpr::_Int);
- try {
- unify(expr->e_type, cnt_type);
- } catch (UnifyError& ue) {
- std::ostringstream os;
- os << "repeat count value of type " << expr->e_type << " is not an integer: " << ue;
- v->get_cond()->error(os.str());
- }
- std::vector<var_idx_t> tmp_vars = expr->pre_compile(code);
- if (tmp_vars.size() != 1) {
- v->get_cond()->error("repeat count value is not a singleton");
- }
+static void process_repeat_statement(V<ast_repeat_statement> v, CodeBlob& code) {
+ std::vector<var_idx_t> tmp_vars = pre_compile_expr(v->get_cond(), code);
Op& repeat_op = code.emplace_back(v->loc, Op::_Repeat, tmp_vars);
code.push_set_cur(repeat_op.block0);
- blk_fl::val res = process_vertex(v->get_body(), code);
+ process_any_statement(v->get_body(), code);
code.close_pop_cur(v->get_body()->loc_end);
- return res | blk_fl::end;
}
-static blk_fl::val process_vertex(V<ast_while_statement> v, CodeBlob& code) {
- Expr* expr = process_expr(v->get_cond(), code);
- expr->chk_rvalue();
- auto cnt_type = TypeExpr::new_atomic(TypeExpr::_Int);
- try {
- unify(expr->e_type, cnt_type);
- } catch (UnifyError& ue) {
- std::ostringstream os;
- os << "while condition value of type " << expr->e_type << " is not an integer: " << ue;
- v->get_cond()->error(os.str());
- }
- Op& while_op = code.emplace_back(v->loc, Op::_While);
- code.push_set_cur(while_op.block0);
- while_op.left = expr->pre_compile(code);
- code.close_pop_cur(v->get_body()->loc);
- if (while_op.left.size() != 1) {
- v->get_cond()->error("while condition value is not a singleton");
+static void process_if_statement(V<ast_if_statement> v, CodeBlob& code) {
+ std::vector<var_idx_t> tmp_vars = pre_compile_expr(v->get_cond(), code);
+ Op& if_op = code.emplace_back(v->loc, Op::_If, std::move(tmp_vars));
+ code.push_set_cur(if_op.block0);
+ process_any_statement(v->get_if_body(), code);
+ code.close_pop_cur(v->get_if_body()->loc_end);
+ code.push_set_cur(if_op.block1);
+ process_any_statement(v->get_else_body(), code);
+ code.close_pop_cur(v->get_else_body()->loc_end);
+ if (v->is_ifnot) {
+ std::swap(if_op.block0, if_op.block1);
}
- code.push_set_cur(while_op.block1);
- blk_fl::val res1 = process_vertex(v->get_body(), code);
- code.close_pop_cur(v->get_body()->loc_end);
- return res1 | blk_fl::end;
}
-static blk_fl::val process_vertex(V<ast_do_while_statement> v, CodeBlob& code) {
+static void process_do_while_statement(V<ast_do_while_statement> v, CodeBlob& code) {
Op& until_op = code.emplace_back(v->loc, Op::_Until);
code.push_set_cur(until_op.block0);
- open_scope(v->loc);
- blk_fl::val res = process_vertex(v->get_body(), code, true);
+ process_any_statement(v->get_body(), code);
// in TVM, there is only "do until", but in Tolk, we want "do while"
// here we negate condition to pass it forward to legacy to Op::_Until
// also, handle common situations as a hardcoded "optimization": replace (a<0) with (a>=0) and so on
// todo these hardcoded conditions should be removed from this place in the future
- AnyV cond = v->get_cond();
- AnyV until_cond;
+ AnyExprV cond = v->get_cond();
+ AnyExprV until_cond;
if (auto v_not = cond->try_as<ast_unary_operator>(); v_not && v_not->tok == tok_logical_not) {
until_cond = v_not->get_rhs();
} else if (auto v_eq = cond->try_as<ast_binary_operator>(); v_eq && v_eq->tok == tok_eq) {
@@ -1093,222 +586,127 @@ static blk_fl::val process_vertex(V<ast_do_while_statement> v, CodeBlob& code) {
until_cond = createV<ast_binary_operator>(cond->loc, "<", tok_lt, v_geq->get_lhs(), v_geq->get_rhs());
} else if (auto v_gt = cond->try_as<ast_binary_operator>(); v_gt && v_gt->tok == tok_gt) {
until_cond = createV<ast_binary_operator>(cond->loc, "<=", tok_geq, v_gt->get_lhs(), v_gt->get_rhs());
+ } else if (cond->inferred_type == TypeDataBool::create()) {
+ until_cond = createV<ast_unary_operator>(cond->loc, "!b", tok_logical_not, cond);
} else {
until_cond = createV<ast_unary_operator>(cond->loc, "!", tok_logical_not, cond);
}
-
- Expr* expr = process_expr(until_cond, code);
- expr->chk_rvalue();
- close_scope();
- auto cnt_type = TypeExpr::new_atomic(TypeExpr::_Int);
- try {
- unify(expr->e_type, cnt_type);
- } catch (UnifyError& ue) {
- std::ostringstream os;
- os << "`while` condition value of type " << expr->e_type << " is not an integer: " << ue;
- v->get_cond()->error(os.str());
+ until_cond->mutate()->assign_inferred_type(TypeDataInt::create());
+ if (auto v_bin = until_cond->try_as<ast_binary_operator>(); v_bin && !v_bin->fun_ref) {
+ v_bin->mutate()->assign_fun_ref(lookup_global_symbol("_" + static_cast<std::string>(v_bin->operator_name) + "_")->as<FunctionData>());
+ } else if (auto v_un = until_cond->try_as<ast_unary_operator>(); v_un && !v_un->fun_ref) {
+ v_un->mutate()->assign_fun_ref(lookup_global_symbol(static_cast<std::string>(v_un->operator_name) + "_")->as<FunctionData>());
}
- until_op.left = expr->pre_compile(code);
+
+ until_op.left = pre_compile_expr(until_cond, code);
code.close_pop_cur(v->get_body()->loc_end);
- if (until_op.left.size() != 1) {
- v->get_cond()->error("`while` condition value is not a singleton");
- }
- return res & ~blk_fl::empty;
}
-static blk_fl::val process_vertex(V<ast_throw_statement> v, CodeBlob& code) {
- std::vector<Expr*> args;
- SymDef* builtin_sym;
- if (v->has_thrown_arg()) {
- builtin_sym = lookup_symbol(calc_sym_idx("__throw_arg"));
- args.push_back(process_expr(v->get_thrown_arg(), code));
- args.push_back(process_expr(v->get_thrown_code(), code));
- } else {
- builtin_sym = lookup_symbol(calc_sym_idx("__throw"));
- args.push_back(process_expr(v->get_thrown_code(), code));
- }
-
- Expr* apply = create_expr_apply(v->loc, builtin_sym, std::move(args));
- apply->flags |= Expr::_IsImpure;
- apply->pre_compile(code);
- return blk_fl::end;
+static void process_while_statement(V<ast_while_statement> v, CodeBlob& code) {
+ Op& while_op = code.emplace_back(v->loc, Op::_While);
+ code.push_set_cur(while_op.block0);
+ while_op.left = pre_compile_expr(v->get_cond(), code);
+ code.close_pop_cur(v->get_body()->loc);
+ code.push_set_cur(while_op.block1);
+ process_any_statement(v->get_body(), code);
+ code.close_pop_cur(v->get_body()->loc_end);
}
-static blk_fl::val process_vertex(V<ast_assert_statement> v, CodeBlob& code) {
- std::vector<Expr*> args(3);
- if (auto v_not = v->get_cond()->try_as<ast_unary_operator>(); v_not && v_not->tok == tok_logical_not) {
- args[0] = process_expr(v->get_thrown_code(), code);
- args[1] = process_expr(v->get_cond()->as<ast_unary_operator>()->get_rhs(), code);
- args[2] = process_expr(createV<ast_bool_const>(v->loc, true), code);
+static void process_throw_statement(V<ast_throw_statement> v, CodeBlob& code) {
+ if (v->has_thrown_arg()) {
+ const FunctionData* builtin_sym = lookup_global_symbol("__throw_arg")->as<FunctionData>();
+ std::vector<var_idx_t> args_vars = pre_compile_tensor(code, {v->get_thrown_arg(), v->get_thrown_code()});
+ gen_op_call(code, TypeDataVoid::create(), v->loc, std::move(args_vars), builtin_sym);
} else {
- args[0] = process_expr(v->get_thrown_code(), code);
- args[1] = process_expr(v->get_cond(), code);
- args[2] = process_expr(createV<ast_bool_const>(v->loc, false), code);
+ const FunctionData* builtin_sym = lookup_global_symbol("__throw")->as<FunctionData>();
+ std::vector<var_idx_t> args_vars = pre_compile_tensor(code, {v->get_thrown_code()});
+ gen_op_call(code, TypeDataVoid::create(), v->loc, std::move(args_vars), builtin_sym);
}
-
- SymDef* builtin_sym = lookup_symbol(calc_sym_idx("__throw_if_unless"));
- Expr* apply = create_expr_apply(v->loc, builtin_sym, std::move(args));
- apply->flags |= Expr::_IsImpure;
- apply->pre_compile(code);
- return blk_fl::end;
}
-static Expr* process_catch_variable(AnyV catch_var, TypeExpr* var_type) {
- if (auto v_ident = catch_var->try_as<ast_identifier>()) {
- return create_new_local_variable(catch_var->loc, v_ident->name, var_type, true);
+static void process_return_statement(V<ast_return_statement> v, CodeBlob& code) {
+ std::vector<var_idx_t> return_vars = v->has_return_value() ? pre_compile_expr(v->get_return_value(), code) : std::vector<var_idx_t>{};
+ if (code.fun_ref->does_return_self()) {
+ tolk_assert(return_vars.size() == 1);
+ return_vars = {};
}
- return create_new_underscore_variable(catch_var->loc, var_type);
-}
-
-static blk_fl::val process_vertex(V<ast_try_catch_statement> v, CodeBlob& code) {
- code.require_callxargs = true;
- Op& try_catch_op = code.emplace_back(v->loc, Op::_TryCatch);
- code.push_set_cur(try_catch_op.block0);
- blk_fl::val res0 = process_vertex(v->get_try_body(), code);
- code.close_pop_cur(v->get_try_body()->loc_end);
- code.push_set_cur(try_catch_op.block1);
- open_scope(v->get_catch_expr()->loc);
-
- // transform catch (excNo, arg) into TVM-catch (arg, excNo), where arg is untyped and thus almost useless now
- TypeExpr* tvm_error_type = TypeExpr::new_tensor(TypeExpr::new_var(), TypeExpr::new_atomic(TypeExpr::_Int));
- const std::vector<AnyV>& catch_items = v->get_catch_expr()->get_items();
- tolk_assert(catch_items.size() == 2);
- Expr* e_catch = new Expr{Expr::_Tensor, v->get_catch_expr()->loc};
- e_catch->pb_arg(process_catch_variable(catch_items[1], tvm_error_type->args[0]));
- e_catch->pb_arg(process_catch_variable(catch_items[0], tvm_error_type->args[1]));
- e_catch->flags = Expr::_IsLvalue;
- e_catch->e_type = tvm_error_type;
- e_catch->predefine_vars();
- e_catch->define_new_vars(code);
- try_catch_op.left = e_catch->pre_compile(code);
- tolk_assert(try_catch_op.left.size() == 2);
-
- blk_fl::val res1 = process_vertex(v->get_catch_body(), code);
- close_scope();
- code.close_pop_cur(v->get_catch_body()->loc_end);
- blk_fl::combine_parallel(res0, res1);
- return res0;
+ if (code.fun_ref->has_mutate_params()) {
+ std::vector<var_idx_t> mutated_vars;
+ for (const LocalVarData& p_sym: code.fun_ref->parameters) {
+ if (p_sym.is_mutate_parameter()) {
+ mutated_vars.push_back(p_sym.idx);
+ }
+ }
+ return_vars.insert(return_vars.begin(), mutated_vars.begin(), mutated_vars.end());
+ }
+ code.emplace_back(v->loc, Op::_Return, std::move(return_vars));
}
-static blk_fl::val process_vertex(V<ast_if_statement> v, CodeBlob& code) {
- Expr* expr = process_expr(v->get_cond(), code);
- expr->chk_rvalue();
- TypeExpr* flag_type = TypeExpr::new_atomic(TypeExpr::_Int);
- try {
- unify(expr->e_type, flag_type);
- } catch (UnifyError& ue) {
- std::ostringstream os;
- os << "`if` condition value of type " << expr->e_type << " is not an integer: " << ue;
- v->get_cond()->error(os.str());
- }
- std::vector<var_idx_t> tmp_vars = expr->pre_compile(code);
- if (tmp_vars.size() != 1) {
- v->get_cond()->error("condition value is not a singleton");
- }
- Op& if_op = code.emplace_back(v->loc, Op::_If, tmp_vars);
- code.push_set_cur(if_op.block0);
- blk_fl::val res1 = process_vertex(v->get_if_body(), code);
- blk_fl::val res2 = blk_fl::init;
- code.close_pop_cur(v->get_if_body()->loc_end);
- code.push_set_cur(if_op.block1);
- res2 = process_vertex(v->get_else_body(), code);
- code.close_pop_cur(v->get_else_body()->loc_end);
- if (v->is_ifnot) {
- std::swap(if_op.block0, if_op.block1);
+static void append_implicit_return_statement(SrcLocation loc_end, CodeBlob& code) {
+ std::vector<var_idx_t> mutated_vars;
+ if (code.fun_ref->has_mutate_params()) {
+ for (const LocalVarData& p_sym: code.fun_ref->parameters) {
+ if (p_sym.is_mutate_parameter()) {
+ mutated_vars.push_back(p_sym.idx);
+ }
+ }
}
- blk_fl::combine_parallel(res1, res2);
- return res1;
+ code.emplace_back(loc_end, Op::_Return, std::move(mutated_vars));
}
-blk_fl::val process_statement(AnyV v, CodeBlob& code) {
+
+void process_any_statement(AnyV v, CodeBlob& code) {
switch (v->type) {
- case ast_local_vars_declaration:
- return process_vertex(v->as<ast_local_vars_declaration>(), code);
- case ast_return_statement:
- return process_vertex(v->as<ast_return_statement>(), code);
case ast_sequence:
- return process_vertex(v->as<ast_sequence>(), code);
- case ast_empty:
- return blk_fl::init;
+ return process_sequence(v->as<ast_sequence>(), code);
+ case ast_return_statement:
+ return process_return_statement(v->as<ast_return_statement>(), code);
case ast_repeat_statement:
- return process_vertex(v->as<ast_repeat_statement>(), code);
+ return process_repeat_statement(v->as<ast_repeat_statement>(), code);
case ast_if_statement:
- return process_vertex(v->as<ast_if_statement>(), code);
+ return process_if_statement(v->as<ast_if_statement>(), code);
case ast_do_while_statement:
- return process_vertex(v->as<ast_do_while_statement>(), code);
+ return process_do_while_statement(v->as<ast_do_while_statement>(), code);
case ast_while_statement:
- return process_vertex(v->as<ast_while_statement>(), code);
+ return process_while_statement(v->as<ast_while_statement>(), code);
case ast_throw_statement:
- return process_vertex(v->as<ast_throw_statement>(), code);
+ return process_throw_statement(v->as<ast_throw_statement>(), code);
case ast_assert_statement:
- return process_vertex(v->as<ast_assert_statement>(), code);
+ return process_assert_statement(v->as<ast_assert_statement>(), code);
case ast_try_catch_statement:
- return process_vertex(v->as<ast_try_catch_statement>(), code);
- default: {
- Expr* expr = process_expr(v, code);
- expr->chk_rvalue();
- expr->pre_compile(code);
- return blk_fl::end;
- }
- }
-}
-
-static FormalArg process_vertex(V<ast_parameter> v, SymDef* param_sym) {
- if (!param_sym) {
- return std::make_tuple(v->param_type, nullptr, v->loc);
- }
- SymDef* new_sym_def = define_symbol(calc_sym_idx(v->get_identifier()->name), true, v->loc);
- if (!new_sym_def || new_sym_def->value) {
- v->error("redefined parameter");
+ return process_try_catch_statement(v->as<ast_try_catch_statement>(), code);
+ case ast_empty_statement:
+ return;
+ default:
+ pre_compile_expr(reinterpret_cast<AnyExprV>(v), code);
}
- const SymValVariable* param_val = dynamic_cast<SymValVariable*>(param_sym->value);
- new_sym_def->value = new SymValVariable(*param_val);
- return std::make_tuple(v->param_type, new_sym_def, v->loc);
}
-static void convert_function_body_to_CodeBlob(V<ast_function_declaration> v, V<ast_sequence> v_body) {
- SymDef* sym_def = lookup_symbol(calc_sym_idx(v->get_identifier()->name));
- SymValCodeFunc* sym_val = dynamic_cast<SymValCodeFunc*>(sym_def->value);
- tolk_assert(sym_val != nullptr);
-
- open_scope(v->loc);
- CodeBlob* blob = new CodeBlob{static_cast<std::string>(v->get_identifier()->name), v->loc, sym_val, v->ret_type};
- if (v->marked_as_pure) {
- blob->flags |= CodeBlob::_ForbidImpure;
- }
+static void convert_function_body_to_CodeBlob(const FunctionData* fun_ref, FunctionBodyCode* code_body) {
+ auto v_body = fun_ref->ast_root->as<ast_function_declaration>()->get_body()->as<ast_sequence>();
+ CodeBlob* blob = new CodeBlob{fun_ref->name, fun_ref->loc, fun_ref};
FormalArgList legacy_arg_list;
- for (int i = 0; i < v->get_num_params(); ++i) {
- legacy_arg_list.emplace_back(process_vertex(v->get_param(i), sym_val->parameters[i]));
+ for (const LocalVarData& param : fun_ref->parameters) {
+ legacy_arg_list.emplace_back(param.declared_type, ¶m, param.loc);
}
blob->import_params(std::move(legacy_arg_list));
- blk_fl::val res = blk_fl::init;
- bool warned = false;
for (AnyV item : v_body->get_items()) {
- if (!(res & blk_fl::end) && !warned) {
- item->loc.show_warning("unreachable code");
- warned = true;
- }
- blk_fl::combine(res, process_statement(item, *blob));
+ process_any_statement(item, *blob);
}
- if (res & blk_fl::end) {
- append_implicit_ret_stmt(v_body->loc_end, *blob);
+ if (fun_ref->is_implicit_return()) {
+ append_implicit_return_statement(v_body->loc_end, *blob);
}
blob->close_blk(v_body->loc_end);
- close_scope();
- sym_val->set_code(blob);
+ code_body->set_code(blob);
}
-static void convert_asm_body_to_AsmOp(V<ast_function_declaration> v, V<ast_asm_body> v_body) {
- SymDef* sym_def = lookup_symbol(calc_sym_idx(v->get_identifier()->name));
- SymValAsmFunc* sym_val = dynamic_cast<SymValAsmFunc*>(sym_def->value);
- tolk_assert(sym_val != nullptr);
-
- int cnt = v->get_num_params();
- int width = v->ret_type->get_width();
+static void convert_asm_body_to_AsmOp(const FunctionData* fun_ref, FunctionBodyAsm* asm_body) {
+ int cnt = fun_ref->get_num_params();
+ int width = fun_ref->inferred_return_type->calc_width_on_stack();
std::vector<AsmOp> asm_ops;
- for (AnyV v_child : v_body->get_asm_commands()) {
+ for (AnyV v_child : fun_ref->ast_root->as<ast_function_declaration>()->get_body()->as<ast_asm_body>()->get_asm_commands()) {
std::string_view ops = v_child->as<ast_string_const>()->str_val; // <op>\n<op>\n...
std::string op;
for (char c : ops) {
@@ -1332,24 +730,77 @@ static void convert_asm_body_to_AsmOp(V<ast_function_declaration> v, V<ast_asm_b
}
}
- sym_val->set_code(std::move(asm_ops));
+ asm_body->set_code(std::move(asm_ops));
}
+class UpdateArgRetOrderConsideringStackWidth final {
+public:
+ static bool should_visit_function(const FunctionData* fun_ref) {
+ return !fun_ref->is_generic_function() && (!fun_ref->ret_order.empty() || !fun_ref->arg_order.empty());
+ }
-void pipeline_convert_ast_to_legacy_Expr_Op(const AllSrcFiles& all_src_files) {
- for (const SrcFile* file : all_src_files) {
- tolk_assert(file->ast);
+ static void start_visiting_function(const FunctionData* fun_ref, V<ast_function_declaration> v_function) {
+ int total_arg_mutate_width = 0;
+ bool has_arg_width_not_1 = false;
+ for (const LocalVarData& param : fun_ref->parameters) {
+ int arg_width = param.declared_type->calc_width_on_stack();
+ has_arg_width_not_1 |= arg_width != 1;
+ total_arg_mutate_width += param.is_mutate_parameter() * arg_width;
+ }
- for (AnyV v : file->ast->as<ast_tolk_file>()->get_toplevel_declarations()) {
- if (auto v_func = v->try_as<ast_function_declaration>()) {
- if (v_func->is_asm_function()) {
- convert_asm_body_to_AsmOp(v_func, v_func->get_body()->as<ast_asm_body>());
- } else if (!v_func->marked_as_builtin) {
- convert_function_body_to_CodeBlob(v_func, v_func->get_body()->as<ast_sequence>());
+ // example: `fun f(a: int, b: (int, (int, int)), c: int)` with `asm (b a c)`
+ // current arg_order is [1 0 2]
+ // needs to be converted to [1 2 3 0 4] because b width is 3
+ if (has_arg_width_not_1) {
+ int total_arg_width = 0;
+ std::vector<int> cum_arg_width;
+ cum_arg_width.reserve(1 + fun_ref->get_num_params());
+ cum_arg_width.push_back(0);
+ for (const LocalVarData& param : fun_ref->parameters) {
+ cum_arg_width.push_back(total_arg_width += param.declared_type->calc_width_on_stack());
+ }
+ std::vector<int> arg_order;
+ for (int i = 0; i < fun_ref->get_num_params(); ++i) {
+ int j = fun_ref->arg_order[i];
+ int c1 = cum_arg_width[j], c2 = cum_arg_width[j + 1];
+ while (c1 < c2) {
+ arg_order.push_back(c1++);
}
}
+ fun_ref->mutate()->assign_arg_order(std::move(arg_order));
+ }
+
+ // example: `fun f(mutate self: slice): slice` with `asm(-> 1 0)`
+ // ret_order is a shuffled range 0...N
+ // validate N: a function should return value and mutated arguments onto a stack
+ if (!fun_ref->ret_order.empty()) {
+ size_t expected_width = fun_ref->inferred_return_type->calc_width_on_stack() + total_arg_mutate_width;
+ if (expected_width != fun_ref->ret_order.size()) {
+ v_function->get_body()->error("ret_order (after ->) expected to contain " + std::to_string(expected_width) + " numbers");
+ }
+ }
+ }
+};
+
+class ConvertASTToLegacyOpVisitor final {
+public:
+ static bool should_visit_function(const FunctionData* fun_ref) {
+ return !fun_ref->is_generic_function();
+ }
+
+ static void start_visiting_function(const FunctionData* fun_ref, V<ast_function_declaration>) {
+ tolk_assert(fun_ref->is_type_inferring_done());
+ if (fun_ref->is_code_function()) {
+ convert_function_body_to_CodeBlob(fun_ref, std::get<FunctionBodyCode*>(fun_ref->body));
+ } else if (fun_ref->is_asm_function()) {
+ convert_asm_body_to_AsmOp(fun_ref, std::get<FunctionBodyAsm*>(fun_ref->body));
}
}
+};
+
+void pipeline_convert_ast_to_legacy_Expr_Op() {
+ visit_ast_of_all_functions<UpdateArgRetOrderConsideringStackWidth>();
+ visit_ast_of_all_functions<ConvertASTToLegacyOpVisitor>();
}
} // namespace tolk
diff --git a/tolk/pipe-calc-rvalue-lvalue.cpp b/tolk/pipe-calc-rvalue-lvalue.cpp
new file mode 100644
index 000000000..041aec891
--- /dev/null
+++ b/tolk/pipe-calc-rvalue-lvalue.cpp
@@ -0,0 +1,217 @@
+/*
+ This file is part of TON Blockchain source code.
+
+ TON Blockchain is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ TON Blockchain is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with TON Blockchain. If not, see <http://www.gnu.org/licenses/>.
+*/
+#include "tolk.h"
+#include "ast.h"
+#include "ast-visitor.h"
+
+/*
+ * This pipe assigns lvalue/rvalue flags for AST expressions.
+ * It happens after identifiers have been resolved, but before type inferring (before methods binding).
+ *
+ * Example: `a = b`, `a` is lvalue, `b` is rvalue.
+ * Example: `a + b`, both are rvalue.
+ *
+ * Note, that this pass only assigns, not checks. So, for `f() = 4`, expr `f()` is lvalue.
+ * Checking (firing this as incorrect later) is performed after type inferring, see pipe-check-rvalue-lvalue.
+ */
+
+namespace tolk {
+
+enum class MarkingState {
+ None,
+ LValue,
+ RValue,
+ LValueAndRValue
+};
+
+class CalculateRvalueLvalueVisitor final : public ASTVisitorFunctionBody {
+ MarkingState cur_state = MarkingState::None;
+
+ MarkingState enter_state(MarkingState activated) {
+ MarkingState saved = cur_state;
+ cur_state = activated;
+ return saved;
+ }
+
+ void restore_state(MarkingState saved) {
+ cur_state = saved;
+ }
+
+ void mark_vertex_cur_or_rvalue(AnyExprV v) const {
+ if (cur_state == MarkingState::LValue || cur_state == MarkingState::LValueAndRValue) {
+ v->mutate()->assign_lvalue_true();
+ }
+ if (cur_state == MarkingState::RValue || cur_state == MarkingState::LValueAndRValue || cur_state == MarkingState::None) {
+ v->mutate()->assign_rvalue_true();
+ }
+ }
+
+ void visit(V<ast_empty_expression> v) override {
+ mark_vertex_cur_or_rvalue(v);
+ }
+
+ void visit(V<ast_parenthesized_expression> v) override {
+ mark_vertex_cur_or_rvalue(v);
+ parent::visit(v);
+ }
+
+ void visit(V<ast_tensor> v) override {
+ mark_vertex_cur_or_rvalue(v);
+ parent::visit(v);
+ }
+
+ void visit(V<ast_typed_tuple> v) override {
+ mark_vertex_cur_or_rvalue(v);
+ parent::visit(v);
+ }
+
+ void visit(V<ast_reference> v) override {
+ mark_vertex_cur_or_rvalue(v);
+ }
+
+ void visit(V<ast_int_const> v) override {
+ mark_vertex_cur_or_rvalue(v);
+ }
+
+ void visit(V<ast_string_const> v) override {
+ mark_vertex_cur_or_rvalue(v);
+ }
+
+ void visit(V<ast_bool_const> v) override {
+ mark_vertex_cur_or_rvalue(v);
+ }
+
+ void visit(V<ast_null_keyword> v) override {
+ mark_vertex_cur_or_rvalue(v);
+ }
+
+ void visit(V<ast_argument> v) override {
+ mark_vertex_cur_or_rvalue(v);
+ MarkingState saved = enter_state(v->passed_as_mutate ? MarkingState::LValueAndRValue : MarkingState::RValue);
+ parent::visit(v);
+ restore_state(saved);
+ }
+
+ void visit(V<ast_argument_list> v) override {
+ mark_vertex_cur_or_rvalue(v);
+ parent::visit(v);
+ }
+
+ void visit(V<ast_dot_access> v) override {
+ mark_vertex_cur_or_rvalue(v);
+ MarkingState saved = enter_state(MarkingState::RValue);
+ parent::visit(v->get_obj());
+ restore_state(saved);
+ }
+
+ void visit(V<ast_function_call> v) override {
+ mark_vertex_cur_or_rvalue(v);
+ MarkingState saved = enter_state(MarkingState::RValue);
+ parent::visit(v);
+ restore_state(saved);
+ }
+
+ void visit(V<ast_underscore> v) override {
+ // underscore is a placeholder to ignore left side of assignment: `(a, _) = get2params()`
+ // so, if current state is "lvalue", `_` will be marked as lvalue, and ok
+ // but if used incorrectly, like `f(_)` or just `_;`, it will be marked rvalue
+ // and will fire an error later, in pipe lvalue/rvalue check
+ mark_vertex_cur_or_rvalue(v);
+ }
+
+ void visit(V<ast_assign> v) override {
+ mark_vertex_cur_or_rvalue(v);
+ MarkingState saved = enter_state(MarkingState::LValue);
+ parent::visit(v->get_lhs());
+ enter_state(MarkingState::RValue);
+ parent::visit(v->get_rhs());
+ restore_state(saved);
+ }
+
+ void visit(V<ast_set_assign> v) override {
+ mark_vertex_cur_or_rvalue(v);
+ MarkingState saved = enter_state(MarkingState::LValueAndRValue);
+ parent::visit(v->get_lhs());
+ enter_state(MarkingState::RValue);
+ parent::visit(v->get_rhs());
+ restore_state(saved);
+ }
+
+ void visit(V<ast_unary_operator> v) override {
+ mark_vertex_cur_or_rvalue(v);
+ MarkingState saved = enter_state(MarkingState::RValue);
+ parent::visit(v);
+ restore_state(saved);
+ }
+
+ void visit(V<ast_binary_operator> v) override {
+ mark_vertex_cur_or_rvalue(v);
+ MarkingState saved = enter_state(MarkingState::RValue);
+ parent::visit(v);
+ restore_state(saved);
+ }
+
+ void visit(V<ast_ternary_operator> v) override {
+ mark_vertex_cur_or_rvalue(v);
+ MarkingState saved = enter_state(MarkingState::RValue);
+ parent::visit(v); // both cond, when_true and when_false are rvalue, `(cond ? a : b) = 5` prohibited
+ restore_state(saved);
+ }
+
+ void visit(V<ast_cast_as_operator> v) override {
+ mark_vertex_cur_or_rvalue(v);
+ parent::visit(v->get_expr()); // leave lvalue state unchanged, for `mutate (t.0 as int)` both `t.0 as int` and `t.0` are lvalue
+ }
+
+ void visit(V<ast_local_var_lhs> v) override {
+ tolk_assert(cur_state == MarkingState::LValue);
+ mark_vertex_cur_or_rvalue(v);
+ parent::visit(v);
+ }
+
+ void visit(V<ast_local_vars_declaration> v) override {
+ tolk_assert(cur_state == MarkingState::LValue);
+ mark_vertex_cur_or_rvalue(v);
+ parent::visit(v);
+ }
+
+ void visit(V<ast_try_catch_statement> v) override {
+ parent::visit(v->get_try_body());
+ MarkingState saved = enter_state(MarkingState::LValue);
+ parent::visit(v->get_catch_expr());
+ restore_state(saved);
+ parent::visit(v->get_catch_body());
+ }
+
+public:
+ bool should_visit_function(const FunctionData* fun_ref) override {
+ return fun_ref->is_code_function() && !fun_ref->is_generic_function();
+ }
+};
+
+void pipeline_calculate_rvalue_lvalue() {
+ visit_ast_of_all_functions<CalculateRvalueLvalueVisitor>();
+}
+
+void pipeline_calculate_rvalue_lvalue(const FunctionData* fun_ref) {
+ CalculateRvalueLvalueVisitor visitor;
+ if (visitor.should_visit_function(fun_ref)) {
+ visitor.start_visiting_function(fun_ref, fun_ref->ast_root->as<ast_function_declaration>());
+ }
+}
+
+} // namespace tolk
diff --git a/tolk/pipe-check-pure-impure.cpp b/tolk/pipe-check-pure-impure.cpp
new file mode 100644
index 000000000..2b2e1e670
--- /dev/null
+++ b/tolk/pipe-check-pure-impure.cpp
@@ -0,0 +1,93 @@
+/*
+ This file is part of TON Blockchain source code.
+
+ TON Blockchain is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ TON Blockchain is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with TON Blockchain. If not, see <http://www.gnu.org/licenses/>.
+*/
+#include "tolk.h"
+#include "ast.h"
+#include "ast-visitor.h"
+#include "platform-utils.h"
+
+/*
+ * This pipe checks for impure operations inside pure functions.
+ * It happens after type inferring (after methods binding) since it operates fun_ref of calls.
+ */
+
+namespace tolk {
+
+GNU_ATTRIBUTE_NORETURN GNU_ATTRIBUTE_COLD
+static void fire_error_impure_operation_inside_pure_function(AnyV v) {
+ v->error("an impure operation in a pure function");
+}
+
+class CheckImpureOperationsInPureFunctionVisitor final : public ASTVisitorFunctionBody {
+ static void fire_if_global_var(AnyExprV v) {
+ if (auto v_ident = v->try_as<ast_reference>()) {
+ if (v_ident->sym->try_as<GlobalVarData>()) {
+ fire_error_impure_operation_inside_pure_function(v);
+ }
+ }
+ }
+
+ void visit(V<ast_assign> v) override {
+ fire_if_global_var(v->get_lhs());
+ parent::visit(v);
+ }
+
+ void visit(V<ast_set_assign> v) override {
+ fire_if_global_var(v->get_lhs());
+ parent::visit(v);
+ }
+
+ void visit(V<ast_function_call> v) override {
+ // v is `globalF(args)` / `globalF<int>(args)` / `obj.method(args)` / `local_var(args)` / `getF()(args)`
+ if (!v->fun_maybe) {
+ // `local_var(args)` is always impure, no considerations about what's there at runtime
+ fire_error_impure_operation_inside_pure_function(v);
+ }
+
+ if (!v->fun_maybe->is_marked_as_pure()) {
+ fire_error_impure_operation_inside_pure_function(v);
+ }
+
+ parent::visit(v);
+ }
+
+ void visit(V<ast_argument> v) override {
+ if (v->passed_as_mutate) {
+ fire_if_global_var(v->get_expr());
+ }
+
+ parent::visit(v);
+ }
+
+ void visit(V<ast_throw_statement> v) override {
+ fire_error_impure_operation_inside_pure_function(v);
+ }
+
+ void visit(V<ast_assert_statement> v) override {
+ fire_error_impure_operation_inside_pure_function(v);
+ }
+
+public:
+ bool should_visit_function(const FunctionData* fun_ref) override {
+ return fun_ref->is_code_function() && !fun_ref->is_generic_function() && fun_ref->is_marked_as_pure();
+ }
+};
+
+void pipeline_check_pure_impure_operations() {
+ visit_ast_of_all_functions<CheckImpureOperationsInPureFunctionVisitor>();
+}
+
+} // namespace tolk
diff --git a/tolk/pipe-check-rvalue-lvalue.cpp b/tolk/pipe-check-rvalue-lvalue.cpp
new file mode 100644
index 000000000..038b09991
--- /dev/null
+++ b/tolk/pipe-check-rvalue-lvalue.cpp
@@ -0,0 +1,198 @@
+/*
+ This file is part of TON Blockchain source code.
+
+ TON Blockchain is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ TON Blockchain is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with TON Blockchain. If not, see <http://www.gnu.org/licenses/>.
+*/
+#include "tolk.h"
+#include "ast.h"
+#include "ast-visitor.h"
+#include "platform-utils.h"
+
+/*
+ * This pipe checks lvalue/rvalue for validity.
+ * It happens after type inferring (after methods binding) and after lvalue/rvalue are refined based on fun_ref.
+ *
+ * Example: `f() = 4`, `f()` was earlier marked as lvalue, it's incorrect.
+ * Example: `f(mutate 5)`, `5` was marked also, it's incorrect.
+ */
+
+namespace tolk {
+
+GNU_ATTRIBUTE_NORETURN GNU_ATTRIBUTE_COLD
+static void fire_error_cannot_be_used_as_lvalue(AnyV v, const std::string& details) {
+ // example: `f() = 32`
+ // example: `loadUint(c.beginParse(), 32)` (since `loadUint()` mutates the first argument)
+ v->error(details + " can not be used as lvalue");
+}
+
+GNU_ATTRIBUTE_NORETURN GNU_ATTRIBUTE_COLD
+static void fire_error_modifying_immutable_variable(AnyExprV v, const LocalVarData* var_ref) {
+ if (var_ref->idx == 0 && var_ref->name == "self") {
+ v->error("modifying `self`, which is immutable by default; probably, you want to declare `mutate self`");
+ } else {
+ v->error("modifying immutable variable `" + var_ref->name + "`");
+ }
+}
+
+// validate a function used as rvalue, like `var cb = f`
+// it's not a generic function (ensured earlier at type inferring) and has some more restrictions
+static void validate_function_used_as_noncall(AnyExprV v, const FunctionData* fun_ref) {
+ if (!fun_ref->arg_order.empty() || !fun_ref->ret_order.empty()) {
+ v->error("saving `" + fun_ref->name + "` into a variable will most likely lead to invalid usage, since it changes the order of variables on the stack");
+ }
+ if (fun_ref->has_mutate_params()) {
+ v->error("saving `" + fun_ref->name + "` into a variable is impossible, since it has `mutate` parameters and thus can only be called directly");
+ }
+}
+
+class CheckRValueLvalueVisitor final : public ASTVisitorFunctionBody {
+ void visit(V<ast_assign> v) override {
+ if (v->is_lvalue) {
+ fire_error_cannot_be_used_as_lvalue(v, "assignment");
+ }
+ parent::visit(v);
+ }
+
+ void visit(V<ast_set_assign> v) override {
+ if (v->is_lvalue) {
+ fire_error_cannot_be_used_as_lvalue(v, "assignment");
+ }
+ parent::visit(v);
+ }
+
+ void visit(V<ast_binary_operator> v) override {
+ if (v->is_lvalue) {
+ fire_error_cannot_be_used_as_lvalue(v, "operator " + static_cast<std::string>(v->operator_name));
+ }
+ parent::visit(v);
+ }
+
+ void visit(V<ast_unary_operator> v) override {
+ if (v->is_lvalue) {
+ fire_error_cannot_be_used_as_lvalue(v, "operator " + static_cast<std::string>(v->operator_name));
+ }
+ parent::visit(v);
+ }
+
+ void visit(V<ast_ternary_operator> v) override {
+ if (v->is_lvalue) {
+ fire_error_cannot_be_used_as_lvalue(v, "operator ?:");
+ }
+ parent::visit(v);
+ }
+
+ void visit(V<ast_cast_as_operator> v) override {
+ // if `x as int` is lvalue, then `x` is also lvalue, so check that `x` is ok
+ parent::visit(v->get_expr());
+ }
+
+ void visit(V<ast_int_const> v) override {
+ if (v->is_lvalue) {
+ fire_error_cannot_be_used_as_lvalue(v, "literal");
+ }
+ }
+
+ void visit(V<ast_string_const> v) override {
+ if (v->is_lvalue) {
+ fire_error_cannot_be_used_as_lvalue(v, "literal");
+ }
+ }
+
+ void visit(V<ast_bool_const> v) override {
+ if (v->is_lvalue) {
+ fire_error_cannot_be_used_as_lvalue(v, "literal");
+ }
+ }
+
+ void visit(V<ast_null_keyword> v) override {
+ if (v->is_lvalue) {
+ fire_error_cannot_be_used_as_lvalue(v, "literal");
+ }
+ }
+
+ void visit(V<ast_dot_access> v) override {
+ // a reference to a method used as rvalue, like `var v = t.tupleAt`
+ if (const FunctionData* fun_ref = v->target; v->is_rvalue) {
+ validate_function_used_as_noncall(v, fun_ref);
+ }
+ }
+
+ void visit(V<ast_function_call> v) override {
+ if (v->is_lvalue) {
+ fire_error_cannot_be_used_as_lvalue(v, "function call");
+ }
+ if (!v->fun_maybe) {
+ parent::visit(v->get_callee());
+ }
+ // for `f()` don't visit ast_reference `f`, to detect `f` usage as non-call, like `var cb = f`
+ // same for `obj.method()`, don't visit ast_reference method, visit only obj
+ if (v->is_dot_call()) {
+ parent::visit(v->get_dot_obj());
+ }
+
+ for (int i = 0; i < v->get_num_args(); ++i) {
+ parent::visit(v->get_arg(i));
+ }
+ }
+
+ void visit(V<ast_local_var_lhs> v) override {
+ if (v->marked_as_redef) {
+ tolk_assert(v->var_ref);
+ if (v->var_ref->is_immutable()) {
+ v->error("`redef` for immutable variable");
+ }
+ }
+ }
+
+ void visit(V<ast_reference> v) override {
+ if (v->is_lvalue) {
+ tolk_assert(v->sym);
+ if (const auto* var_ref = v->sym->try_as<LocalVarData>(); var_ref && var_ref->is_immutable()) {
+ fire_error_modifying_immutable_variable(v, var_ref);
+ } else if (v->sym->try_as<GlobalConstData>()) {
+ v->error("modifying immutable constant");
+ } else if (v->sym->try_as<FunctionData>()) {
+ v->error("function can't be used as lvalue");
+ }
+ }
+
+ // a reference to a function used as rvalue, like `var v = someFunction`
+ if (const FunctionData* fun_ref = v->sym->try_as<FunctionData>(); fun_ref && v->is_rvalue) {
+ validate_function_used_as_noncall(v, fun_ref);
+ }
+ }
+
+ void visit(V<ast_underscore> v) override {
+ if (v->is_rvalue) {
+ v->error("`_` can't be used as a value; it's a placeholder for a left side of assignment");
+ }
+ }
+
+ void visit(V<ast_try_catch_statement> v) override {
+ parent::visit(v->get_try_body());
+ // skip catch(_,excNo), there are always vars due to grammar, lvalue/rvalue aren't set to them
+ parent::visit(v->get_catch_body());
+ }
+
+public:
+ bool should_visit_function(const FunctionData* fun_ref) override {
+ return fun_ref->is_code_function() && !fun_ref->is_generic_function();
+ }
+};
+
+void pipeline_check_rvalue_lvalue() {
+ visit_ast_of_all_functions<CheckRValueLvalueVisitor>();
+}
+
+} // namespace tolk
diff --git a/tolk/pipe-constant-folding.cpp b/tolk/pipe-constant-folding.cpp
new file mode 100644
index 000000000..98996c28d
--- /dev/null
+++ b/tolk/pipe-constant-folding.cpp
@@ -0,0 +1,91 @@
+/*
+ This file is part of TON Blockchain source code.
+
+ TON Blockchain is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ TON Blockchain is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with TON Blockchain. If not, see <http://www.gnu.org/licenses/>.
+*/
+#include "tolk.h"
+#include "ast.h"
+#include "ast-replacer.h"
+#include "type-system.h"
+
+/*
+ * This pipe is supposed to do constant folding, like replacing `2 + 3` with `5`.
+ * It happens after type inferring and validity checks, one of the last ones.
+ *
+ * Currently, it just replaces `-1` (ast_unary_operator ast_int_const) with a number -1
+ * and `!true` with false.
+ * More rich constant folding should be done some day, but even without this, IR optimizations
+ * (operating low-level stack variables) pretty manage to do all related optimizations.
+ * Constant folding in the future, done at AST level, just would slightly reduce amount of work for optimizer.
+ */
+
+namespace tolk {
+
+class ConstantFoldingReplacer final : public ASTReplacerInFunctionBody {
+ static V<ast_int_const> create_int_const(SrcLocation loc, td::RefInt256&& intval) {
+ auto v_int = createV<ast_int_const>(loc, std::move(intval), {});
+ v_int->assign_inferred_type(TypeDataInt::create());
+ v_int->assign_rvalue_true();
+ return v_int;
+ }
+
+ static V<ast_bool_const> create_bool_const(SrcLocation loc, bool bool_val) {
+ auto v_bool = createV<ast_bool_const>(loc, bool_val);
+ v_bool->assign_inferred_type(TypeDataBool::create());
+ v_bool->assign_rvalue_true();
+ return v_bool;
+ }
+
+ AnyExprV replace(V<ast_unary_operator> v) override {
+ parent::replace(v);
+
+ TokenType t = v->tok;
+ // convert "-1" (tok_minus tok_int_const) to a const -1
+ if (t == tok_minus && v->get_rhs()->type == ast_int_const) {
+ td::RefInt256 intval = v->get_rhs()->as<ast_int_const>()->intval;
+ tolk_assert(!intval.is_null());
+ intval = -intval;
+ if (intval.is_null() || !intval->signed_fits_bits(257)) {
+ v->error("integer overflow");
+ }
+ return create_int_const(v->loc, std::move(intval));
+ }
+ // same for "+1"
+ if (t == tok_plus && v->get_rhs()->type == ast_int_const) {
+ return v->get_rhs();
+ }
+
+ // `!true` / `!false`
+ if (t == tok_logical_not && v->get_rhs()->type == ast_bool_const) {
+ return create_bool_const(v->loc, !v->get_rhs()->as<ast_bool_const>()->bool_val);
+ }
+ // `!0`
+ if (t == tok_logical_not && v->get_rhs()->type == ast_int_const) {
+ return create_bool_const(v->loc, v->get_rhs()->as<ast_int_const>()->intval == 0);
+ }
+
+ return v;
+ }
+
+public:
+ bool should_visit_function(const FunctionData* fun_ref) override {
+ return fun_ref->is_code_function() && !fun_ref->is_generic_function();
+ }
+};
+
+void pipeline_constant_folding() {
+ replace_ast_of_all_functions<ConstantFoldingReplacer>();
+}
+
+} // namespace tolk
diff --git a/tolk/pipe-detect-unreachable.cpp b/tolk/pipe-detect-unreachable.cpp
new file mode 100644
index 000000000..15824cf39
--- /dev/null
+++ b/tolk/pipe-detect-unreachable.cpp
@@ -0,0 +1,138 @@
+/*
+ This file is part of TON Blockchain source code.
+
+ TON Blockchain is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ TON Blockchain is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with TON Blockchain. If not, see <http://www.gnu.org/licenses/>.
+*/
+#include "tolk.h"
+#include "ast.h"
+#include "ast-visitor.h"
+
+/*
+ * This pipe does two things:
+ * 1) detects unreachable code and prints warnings about it
+ * example: `fun main() { if(1){return;}else{return;} var x = 0; }` — var is unreachable
+ * 2) if control flow reaches end of function, store a flag to insert an implicit return
+ * example: `fun main() { assert(...); }` — has an implicit `return ()` statement before a brace
+ *
+ * Note, that it does not delete unreachable code, only prints warnings.
+ * Actual deleting is done much later (in "legacy" part), after AST is converted to Op.
+ *
+ * Note, that it's not CFG, it's just a shallow reachability detection.
+ * In the future, a true CFG should be introduced. For instance, in order to have nullable types,
+ * I'll need to implement smart casts. Then I'll think of a complicated granular control flow graph,
+ * considering data flow and exceptions (built before type inferring, of course),
+ * and detecting unreachable code will be a part of it.
+ */
+
+namespace tolk {
+
+class UnreachableStatementsDetectVisitor final {
+ bool always_returns(AnyV v) {
+ switch (v->type) {
+ case ast_sequence: return always_returns(v->as<ast_sequence>());
+ case ast_return_statement: return always_returns(v->as<ast_return_statement>());
+ case ast_throw_statement: return always_returns(v->as<ast_throw_statement>());
+ case ast_function_call: return always_returns(v->as<ast_function_call>());
+ case ast_repeat_statement: return always_returns(v->as<ast_repeat_statement>());
+ case ast_while_statement: return always_returns(v->as<ast_while_statement>());
+ case ast_do_while_statement: return always_returns(v->as<ast_do_while_statement>());
+ case ast_try_catch_statement: return always_returns(v->as<ast_try_catch_statement>());
+ case ast_if_statement: return always_returns(v->as<ast_if_statement>());
+ default:
+ // unhandled statements (like assert) and statement expressions
+ return false;
+ }
+ }
+
+ bool always_returns(V<ast_sequence> v) {
+ bool always = false;
+ for (AnyV item : v->get_items()) {
+ if (always && item->type != ast_empty_statement) {
+ item->loc.show_warning("unreachable code");
+ break;
+ }
+ always |= always_returns(item);
+ }
+ return always;
+ }
+
+ static bool always_returns([[maybe_unused]] V<ast_return_statement> v) {
+ // quite obvious: `return expr` interrupts control flow
+ return true;
+ }
+
+ static bool always_returns([[maybe_unused]] V<ast_throw_statement> v) {
+ // todo `throw excNo` currently does not interrupt control flow
+ // (in other words, `throw 1; something` - something is reachable)
+ // the reason is that internally it's transformed to a call of built-in function __throw(),
+ // which is a regular function, like __throw_if() or loadInt()
+ // to fix this later on, it should be deeper, introducing Op::_Throw for example,
+ // to make intermediate representations and stack optimizer also be aware that after it there is unreachable
+ return false;
+ }
+
+ static bool always_returns([[maybe_unused]] V<ast_function_call> v) {
+ // neither annotations like @noreturn nor auto-detection of always-throwing functions also doesn't exist
+ // in order to do this in the future, it should be handled not only at AST/CFG level,
+ // but inside Op and low-level optimizer (at least if reachability detection is not moved out of there)
+ // see comments for `throw` above, similar to this case
+ return false;
+ }
+
+ bool always_returns(V<ast_repeat_statement> v) {
+ return always_returns(v->get_body());
+ }
+
+ bool always_returns(V<ast_while_statement> v) {
+ return always_returns(v->get_body());
+ }
+
+ bool always_returns(V<ast_do_while_statement> v) {
+ return always_returns(v->get_body());
+ }
+
+ bool always_returns(V<ast_try_catch_statement> v) {
+ return always_returns(v->get_try_body()) && always_returns(v->get_catch_body());
+ }
+
+ bool always_returns(V<ast_if_statement> v) {
+ return always_returns(v->get_if_body()) && always_returns(v->get_else_body());
+ }
+
+public:
+ static bool should_visit_function(const FunctionData* fun_ref) {
+ return fun_ref->is_code_function() && !fun_ref->is_generic_function();
+ }
+
+ void start_visiting_function(const FunctionData* fun_ref, V<ast_function_declaration> v_function) {
+ bool control_flow_reaches_end = !always_returns(v_function->get_body()->as<ast_sequence>());
+ if (control_flow_reaches_end) {
+ fun_ref->mutate()->assign_is_implicit_return();
+ }
+ }
+};
+
+
+void pipeline_detect_unreachable_statements() {
+ visit_ast_of_all_functions<UnreachableStatementsDetectVisitor>();
+}
+
+void pipeline_detect_unreachable_statements(const FunctionData* fun_ref) {
+ UnreachableStatementsDetectVisitor visitor;
+ if (UnreachableStatementsDetectVisitor::should_visit_function(fun_ref)) {
+ visitor.start_visiting_function(fun_ref, fun_ref->ast_root->as<ast_function_declaration>());
+ }
+}
+
+} // namespace tolk
diff --git a/tolk/pipe-discover-parse-sources.cpp b/tolk/pipe-discover-parse-sources.cpp
index a8445ae95..d31348ba9 100644
--- a/tolk/pipe-discover-parse-sources.cpp
+++ b/tolk/pipe-discover-parse-sources.cpp
@@ -28,9 +28,17 @@
#include "ast-from-tokens.h"
#include "compiler-state.h"
+/*
+ * This is the starting point of compilation pipeline.
+ * It parses Tolk files to AST, analyzes `import` statements and loads/parses imported files.
+ *
+ * When it finishes, all files have been parsed to AST, and no more files will later be added.
+ * If a parsing error happens (invalid syntax), an exception is thrown immediately from ast-from-tokens.cpp.
+ */
+
namespace tolk {
-AllSrcFiles pipeline_discover_and_parse_sources(const std::string& stdlib_filename, const std::string& entrypoint_filename) {
+void pipeline_discover_and_parse_sources(const std::string& stdlib_filename, const std::string& entrypoint_filename) {
G.all_src_files.locate_and_register_source_file(stdlib_filename, {});
G.all_src_files.locate_and_register_source_file(entrypoint_filename, {});
@@ -38,27 +46,25 @@ AllSrcFiles pipeline_discover_and_parse_sources(const std::string& stdlib_filena
tolk_assert(!file->ast);
file->ast = parse_src_file_to_ast(file);
- // file->ast->debug_print();
+ // if (!file->is_stdlib_file()) file->ast->debug_print();
for (AnyV v_toplevel : file->ast->as<ast_tolk_file>()->get_toplevel_declarations()) {
- if (auto v_import = v_toplevel->try_as<ast_import_statement>()) {
+ if (auto v_import = v_toplevel->try_as<ast_import_directive>()) {
std::string imported_str = v_import->get_file_name();
size_t cur_slash_pos = file->rel_filename.rfind('/');
std::string rel_filename = cur_slash_pos == std::string::npos || imported_str[0] == '@'
? std::move(imported_str)
: file->rel_filename.substr(0, cur_slash_pos + 1) + imported_str;
- SrcFile* imported = G.all_src_files.locate_and_register_source_file(rel_filename, v_import->loc);
- file->imports.push_back(SrcFile::ImportStatement{imported});
- v_import->mutate_set_src_file(imported);
+ const SrcFile* imported = G.all_src_files.locate_and_register_source_file(rel_filename, v_import->loc);
+ file->imports.push_back(SrcFile::ImportDirective{imported});
+ v_import->mutate()->assign_src_file(imported);
}
}
}
// todo #ifdef TOLK_PROFILING
- // lexer_measure_performance(G.all_src_files.get_all_files());
-
- return G.all_src_files.get_all_files();
+ lexer_measure_performance(G.all_src_files);
}
} // namespace tolk
diff --git a/tolk/pipe-find-unused-symbols.cpp b/tolk/pipe-find-unused-symbols.cpp
index f83579f4e..29584cbf7 100644
--- a/tolk/pipe-find-unused-symbols.cpp
+++ b/tolk/pipe-find-unused-symbols.cpp
@@ -24,51 +24,41 @@
from all source files in the program, then also delete it here.
*/
#include "tolk.h"
-#include "src-file.h"
#include "compiler-state.h"
/*
- * Here we find unused symbols (global functions and variables) to strip them off codegen.
- * Note, that currently it's implemented as a standalone step after AST has been transformed to legacy Expr/Op.
- * The reason why it's not done on AST level is that symbol resolving is done too late. For instance,
- * having `beginCell()` there is not enough information in AST whether if points to a global function
- * or it's a local variable application.
- * In the future, this should be done on AST level.
+ * This pipe finds unused symbols (global functions and variables) to strip them off codegen.
+ * It happens after converting AST to Op, so it does not traverse AST.
+ * In the future, when control flow graph is introduced, this should be done at AST level.
*/
namespace tolk {
static void mark_function_used_dfs(const std::unique_ptr<Op>& op);
-static void mark_function_used(SymValCodeFunc* func_val) {
- if (!func_val->code || func_val->is_really_used) { // already handled
+static void mark_function_used(const FunctionData* fun_ref) {
+ if (!fun_ref->is_code_function() || fun_ref->is_really_used()) { // already handled
return;
}
- func_val->is_really_used = true;
- mark_function_used_dfs(func_val->code->ops);
+ fun_ref->mutate()->assign_is_really_used();
+ mark_function_used_dfs(std::get<FunctionBodyCode*>(fun_ref->body)->code->ops);
}
-static void mark_global_var_used(SymValGlobVar* glob_val) {
- glob_val->is_really_used = true;
+static void mark_global_var_used(const GlobalVarData* glob_ref) {
+ glob_ref->mutate()->assign_is_really_used();
}
static void mark_function_used_dfs(const std::unique_ptr<Op>& op) {
if (!op) {
return;
}
- // op->fun_ref, despite its name, may actually ref global var
- // note, that for non-calls, e.g. `var a = some_fn` (Op::_Let), some_fn is Op::_GlobVar
- // (in other words, fun_ref exists not only for direct Op::_Call, but for non-call references also)
- if (op->fun_ref) {
- if (auto* func_val = dynamic_cast<SymValCodeFunc*>(op->fun_ref->value)) {
- mark_function_used(func_val);
- } else if (auto* glob_val = dynamic_cast<SymValGlobVar*>(op->fun_ref->value)) {
- mark_global_var_used(glob_val);
- } else if (auto* asm_val = dynamic_cast<SymValAsmFunc*>(op->fun_ref->value)) {
- } else {
- tolk_assert(false);
- }
+
+ if (op->f_sym) { // for Op::_Call
+ mark_function_used(op->f_sym);
+ }
+ if (op->g_sym) { // for Op::_GlobVar
+ mark_global_var_used(op->g_sym);
}
mark_function_used_dfs(op->next);
mark_function_used_dfs(op->block0);
@@ -76,11 +66,9 @@ static void mark_function_used_dfs(const std::unique_ptr<Op>& op) {
}
void pipeline_find_unused_symbols() {
- for (SymDef* func_sym : G.all_code_functions) {
- auto* func_val = dynamic_cast<SymValCodeFunc*>(func_sym->value);
- std::string name = G.symbols.get_name(func_sym->sym_idx);
- if (func_val->method_id.not_null() || func_val->is_entrypoint()) {
- mark_function_used(func_val);
+ for (const FunctionData* fun_ref : G.all_functions) {
+ if (fun_ref->is_method_id_not_empty()) { // get methods, main and other entrypoints, regular functions with @method_id
+ mark_function_used(fun_ref);
}
}
}
diff --git a/tolk/pipe-generate-fif-output.cpp b/tolk/pipe-generate-fif-output.cpp
index 91a99f96a..9092e5647 100644
--- a/tolk/pipe-generate-fif-output.cpp
+++ b/tolk/pipe-generate-fif-output.cpp
@@ -1,5 +1,5 @@
/*
- This file is part of TON Blockchain source code.
+ This file is part of TON Blockchain source code->
TON Blockchain is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
@@ -30,113 +30,88 @@
namespace tolk {
-bool SymValCodeFunc::does_need_codegen() const {
- // when a function is declared, but not referenced from code in any way, don't generate its body
- if (!is_really_used && G.settings.remove_unused_functions) {
- return false;
- }
- // when a function is referenced like `var a = some_fn;` (or in some other non-call way), its continuation should exist
- if (flags & flagUsedAsNonCall) {
- return true;
- }
- // currently, there is no inlining, all functions are codegenerated
- // (but actually, unused ones are later removed by Fift)
- // in the future, we may want to implement a true AST inlining for "simple" functions
- return true;
-}
-
-void SymValCodeFunc::set_code(CodeBlob* code) {
+void FunctionBodyCode::set_code(CodeBlob* code) {
this->code = code;
}
-void SymValAsmFunc::set_code(std::vector<AsmOp> code) {
- this->ext_compile = make_ext_compile(std::move(code));
+void FunctionBodyAsm::set_code(std::vector<AsmOp>&& code) {
+ this->ops = std::move(code);
}
-static void generate_output_func(SymDef* func_sym) {
- SymValCodeFunc* func_val = dynamic_cast<SymValCodeFunc*>(func_sym->value);
- tolk_assert(func_val);
- std::string name = G.symbols.get_name(func_sym->sym_idx);
+static void generate_output_func(const FunctionData* fun_ref) {
+ tolk_assert(fun_ref->is_code_function());
if (G.is_verbosity(2)) {
- std::cerr << "\n\n=========================\nfunction " << name << " : " << func_val->get_type() << std::endl;
- }
- if (!func_val->code) {
- throw ParseError(func_sym->loc, "function `" + name + "` is just declared, not implemented");
- } else {
- CodeBlob& code = *(func_val->code);
- if (G.is_verbosity(3)) {
- code.print(std::cerr, 9);
+ std::cerr << "\n\n=========================\nfunction " << fun_ref->name << " : " << fun_ref->inferred_return_type << std::endl;
+ }
+
+ CodeBlob* code = std::get<FunctionBodyCode*>(fun_ref->body)->code;
+ if (G.is_verbosity(3)) {
+ code->print(std::cerr, 9);
+ }
+ code->prune_unreachable_code();
+ if (G.is_verbosity(5)) {
+ std::cerr << "after prune_unreachable: \n";
+ code->print(std::cerr, 0);
+ }
+ code->split_vars(true);
+ if (G.is_verbosity(5)) {
+ std::cerr << "after split_vars: \n";
+ code->print(std::cerr, 0);
+ }
+ for (int i = 0; i < 8; i++) {
+ code->compute_used_code_vars();
+ if (G.is_verbosity(4)) {
+ std::cerr << "after compute_used_vars: \n";
+ code->print(std::cerr, 6);
}
- code.simplify_var_types();
+ code->fwd_analyze();
if (G.is_verbosity(5)) {
- std::cerr << "after simplify_var_types: \n";
- code.print(std::cerr, 0);
+ std::cerr << "after fwd_analyze: \n";
+ code->print(std::cerr, 6);
}
- code.prune_unreachable_code();
+ code->prune_unreachable_code();
if (G.is_verbosity(5)) {
std::cerr << "after prune_unreachable: \n";
- code.print(std::cerr, 0);
- }
- code.split_vars(true);
- if (G.is_verbosity(5)) {
- std::cerr << "after split_vars: \n";
- code.print(std::cerr, 0);
- }
- for (int i = 0; i < 8; i++) {
- code.compute_used_code_vars();
- if (G.is_verbosity(4)) {
- std::cerr << "after compute_used_vars: \n";
- code.print(std::cerr, 6);
- }
- code.fwd_analyze();
- if (G.is_verbosity(5)) {
- std::cerr << "after fwd_analyze: \n";
- code.print(std::cerr, 6);
- }
- code.prune_unreachable_code();
- if (G.is_verbosity(5)) {
- std::cerr << "after prune_unreachable: \n";
- code.print(std::cerr, 6);
- }
- }
- code.mark_noreturn();
- if (G.is_verbosity(3)) {
- code.print(std::cerr, 15);
- }
- if (G.is_verbosity(2)) {
- std::cerr << "\n---------- resulting code for " << name << " -------------\n";
- }
- const char* modifier = "";
- if (func_val->is_inline()) {
- modifier = "INLINE";
- } else if (func_val->is_inline_ref()) {
- modifier = "REF";
- }
- std::cout << std::string(2, ' ') << name << " PROC" << modifier << ":<{\n";
- int mode = 0;
- if (G.settings.stack_layout_comments) {
- mode |= Stack::_StkCmt | Stack::_CptStkCmt;
- }
- if (func_val->is_inline() && code.ops->noreturn()) {
- mode |= Stack::_InlineFunc;
- }
- if (func_val->is_inline() || func_val->is_inline_ref()) {
- mode |= Stack::_InlineAny;
- }
- code.generate_code(std::cout, mode, 2);
- std::cout << std::string(2, ' ') << "}>\n";
- if (G.is_verbosity(2)) {
- std::cerr << "--------------\n";
+ code->print(std::cerr, 6);
}
}
+ code->mark_noreturn();
+ if (G.is_verbosity(3)) {
+ code->print(std::cerr, 15);
+ }
+ if (G.is_verbosity(2)) {
+ std::cerr << "\n---------- resulting code for " << fun_ref->name << " -------------\n";
+ }
+ const char* modifier = "";
+ if (fun_ref->is_inline()) {
+ modifier = "INLINE";
+ } else if (fun_ref->is_inline_ref()) {
+ modifier = "REF";
+ }
+ std::cout << std::string(2, ' ') << fun_ref->name << " PROC" << modifier << ":<{\n";
+ int mode = 0;
+ if (G.settings.stack_layout_comments) {
+ mode |= Stack::_StkCmt | Stack::_CptStkCmt;
+ }
+ if (fun_ref->is_inline() && code->ops->noreturn()) {
+ mode |= Stack::_InlineFunc;
+ }
+ if (fun_ref->is_inline() || fun_ref->is_inline_ref()) {
+ mode |= Stack::_InlineAny;
+ }
+ code->generate_code(std::cout, mode, 2);
+ std::cout << std::string(2, ' ') << "}>\n";
+ if (G.is_verbosity(2)) {
+ std::cerr << "--------------\n";
+ }
}
-void pipeline_generate_fif_output_to_std_cout(const AllSrcFiles& all_src_files) {
+void pipeline_generate_fif_output_to_std_cout() {
std::cout << "\"Asm.fif\" include\n";
std::cout << "// automatically generated from ";
bool need_comma = false;
- for (const SrcFile* file : all_src_files) {
+ for (const SrcFile* file : G.all_src_files) {
if (!file->is_stdlib_file()) {
if (need_comma) {
std::cout << ", ";
@@ -149,26 +124,23 @@ void pipeline_generate_fif_output_to_std_cout(const AllSrcFiles& all_src_files)
std::cout << "PROGRAM{\n";
bool has_main_procedure = false;
- for (SymDef* func_sym : G.all_code_functions) {
- SymValCodeFunc* func_val = dynamic_cast<SymValCodeFunc*>(func_sym->value);
- tolk_assert(func_val);
- if (!func_val->does_need_codegen()) {
- if (G.is_verbosity(2)) {
- std::cerr << func_sym->name() << ": code not generated, function does not need codegen\n";
+ for (const FunctionData* fun_ref : G.all_functions) {
+ if (!fun_ref->does_need_codegen()) {
+ if (G.is_verbosity(2) && fun_ref->is_code_function()) {
+ std::cerr << fun_ref->name << ": code not generated, function does not need codegen\n";
}
continue;
}
- std::string name = G.symbols.get_name(func_sym->sym_idx);
- if (func_val->is_entrypoint() && (name == "main" || name == "onInternalMessage")) {
+ if (fun_ref->is_entrypoint() && (fun_ref->name == "main" || fun_ref->name == "onInternalMessage")) {
has_main_procedure = true;
}
std::cout << std::string(2, ' ');
- if (func_val->method_id.is_null()) {
- std::cout << "DECLPROC " << name << "\n";
+ if (fun_ref->is_method_id_not_empty()) {
+ std::cout << fun_ref->method_id << " DECLMETHOD " << fun_ref->name << "\n";
} else {
- std::cout << func_val->method_id << " DECLMETHOD " << name << "\n";
+ std::cout << "DECLPROC " << fun_ref->name << "\n";
}
}
@@ -176,25 +148,22 @@ void pipeline_generate_fif_output_to_std_cout(const AllSrcFiles& all_src_files)
throw Fatal("the contract has no entrypoint; forgot `fun onInternalMessage(...)`?");
}
- for (SymDef* gvar_sym : G.all_global_vars) {
- auto* glob_val = dynamic_cast<SymValGlobVar*>(gvar_sym->value);
- tolk_assert(glob_val);
- if (!glob_val->is_really_used && G.settings.remove_unused_functions) {
+ for (const GlobalVarData* var_ref : G.all_global_vars) {
+ if (!var_ref->is_really_used() && G.settings.remove_unused_functions) {
if (G.is_verbosity(2)) {
- std::cerr << gvar_sym->name() << ": variable not generated, it's unused\n";
+ std::cerr << var_ref->name << ": variable not generated, it's unused\n";
}
continue;
}
- std::string name = G.symbols.get_name(gvar_sym->sym_idx);
- std::cout << std::string(2, ' ') << "DECLGLOBVAR " << name << "\n";
+
+ std::cout << std::string(2, ' ') << "DECLGLOBVAR " << var_ref->name << "\n";
}
- for (SymDef* func_sym : G.all_code_functions) {
- SymValCodeFunc* func_val = dynamic_cast<SymValCodeFunc*>(func_sym->value);
- if (!func_val->does_need_codegen()) {
+ for (const FunctionData* fun_ref : G.all_functions) {
+ if (!fun_ref->does_need_codegen()) {
continue;
}
- generate_output_func(func_sym);
+ generate_output_func(fun_ref);
}
std::cout << "}END>c\n";
diff --git a/tolk/pipe-infer-types-and-calls.cpp b/tolk/pipe-infer-types-and-calls.cpp
new file mode 100644
index 000000000..d8a7d41be
--- /dev/null
+++ b/tolk/pipe-infer-types-and-calls.cpp
@@ -0,0 +1,1236 @@
+/*
+ This file is part of TON Blockchain Library.
+
+ TON Blockchain Library is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Lesser General Public License as published by
+ the Free Software Foundation, either version 2 of the License, or
+ (at your option) any later version.
+
+ TON Blockchain Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public License
+ along with TON Blockchain Library. If not, see <http://www.gnu.org/licenses/>.
+*/
+#include "tolk.h"
+#include "src-file.h"
+#include "ast.h"
+#include "ast-visitor.h"
+#include "generics-helpers.h"
+#include "type-system.h"
+
+/*
+ * This is a complicated and crucial part of the pipeline. It simultaneously does the following:
+ * * infers types of all expressions; example: `2 + 3` both are TypeDataInt, result is also
+ * * AND checks types for assignment, arguments passing, etc.; example: `fInt(cs)` is error passing slice to int
+ * * AND binds function/method calls (assigns fun_ref); example: `globalF()`, fun_ref is assigned to `globalF` (unless generic)
+ * * AND instantiates generic functions; example: `t.tuplePush(2)` creates `tuplePush<int>` and assigns fun_ref to dot field
+ * * AND infers return type of functions if it's omitted (`fun f() { ... }` means "auto infer", not "void")
+ *
+ * It's important to do all these parts simultaneously, they can't be split or separated.
+ * For example, we can't bind `f(2)` earlier, because if `f` is a generic `f<T>`, we should instantiate it,
+ * and in order to do it, we need to know argument types.
+ * For example, we can't bind `c.cellHash()` earlier, because in the future we'll have overloads (`cell.hash()` and `slice.hash()`),
+ * and in order to bind it, we need to know object type.
+ * And vice versa, to infer type of expression in the middle, we need to have inferred all expressions preceding it,
+ * which may also include generics, etc.
+ *
+ * About generics. They are more like "C++ templates". If `f<int>` and `f<slice>` called from somewhere,
+ * there will be TWO new functions, inserted into symtable, and both will be code generated to Fift.
+ * Body of a generic function is NOT analyzed. Hence, `fun f<T>(v: T) { v.method(); }` we don't know
+ * whether `v.method()` is a valid call until instantiate it with `f<slice>` for example.
+ * Same for `v + 2`, we don't know whether + operator can be applied until instantiation.
+ * In other words, we have a closed type system, not open.
+ * That's why generic functions' bodies aren't traversed here (and in most following pipes).
+ * Instead, when an instantiated function is created, it follows all the preceding pipeline (registering symbols, etc.),
+ * and type inferring is done inside instantiated functions (which can recursively instantiate another, etc.).
+ *
+ * A noticeable part of inferring is "hints".
+ * Example: `var a: User = { id: 3, name: "" }`. To infer type of `{...}` we need to know it's `User`. This hint is taken from lhs.
+ * Example: `fun tupleAt<T>(t: tuple, idx: int):T`, just `t.tupleGet(2)` can't be deduced (T left unspecified),
+ * but for assignment with left-defined type, or a call to `fInt(t.tupleGet(2))` hint "int" helps deduce T.
+ *
+ * Unlike other pipes, inferring can dig recursively on demand.
+ * Example:
+ * fun getInt() { return 1; }
+ * fun main() { var i = getInt(); }
+ * If `main` is handled the first, it should know the return type if `getInt`. It's not declared, so we need
+ * to launch type inferring for `getInt` and then proceed back to `main`.
+ * When a generic function is instantiated, type inferring inside it is also run.
+ */
+
+namespace tolk {
+
+static void infer_and_save_return_type_of_function(const FunctionData* fun_ref);
+
+static TypePtr get_or_infer_return_type(const FunctionData* fun_ref) {
+ if (!fun_ref->inferred_return_type) {
+ infer_and_save_return_type_of_function(fun_ref);
+ }
+ return fun_ref->inferred_return_type;
+}
+
+GNU_ATTRIBUTE_NOINLINE
+static std::string to_string(TypePtr type) {
+ return "`" + type->as_human_readable() + "`";
+}
+
+GNU_ATTRIBUTE_NOINLINE
+static std::string to_string(AnyExprV v_with_type) {
+ return "`" + v_with_type->inferred_type->as_human_readable() + "`";
+}
+
+GNU_ATTRIBUTE_NOINLINE
+static std::string to_string(const LocalVarData& var_ref) {
+ return "`" + var_ref.declared_type->as_human_readable() + "`";
+}
+
+GNU_ATTRIBUTE_NOINLINE
+static std::string to_string(const FunctionData* fun_ref) {
+ return "`" + fun_ref->as_human_readable() + "`";
+}
+
+// fire an error when `fun f<T>(...) asm ...` is called with T=(int,int) or other non-1 width on stack
+// asm functions generally can't handle it, they expect T to be a TVM primitive
+// (in FunC, `forall` type just couldn't be unified with non-primitives; in Tolk, generic T is expectedly inferred)
+GNU_ATTRIBUTE_NORETURN GNU_ATTRIBUTE_COLD
+static void fire_error_calling_asm_function_with_non1_stack_width_arg(SrcLocation loc, const FunctionData* fun_ref, const std::vector<TypePtr>& substitutions, int arg_idx) {
+ throw ParseError(loc, "can not call `" + fun_ref->as_human_readable() + "` with " + fun_ref->genericTs->get_nameT(arg_idx) + "=" + substitutions[arg_idx]->as_human_readable() + ", because it occupies " + std::to_string(substitutions[arg_idx]->calc_width_on_stack()) + " stack slots in TVM, not 1");
+}
+
+// fire an error on `var n = null`
+// technically it's correct, type of `n` is TypeDataNullLiteral, but it's not what the user wanted
+// so, it's better to see an error on assignment, that later, on `n` usage and types mismatch
+// (most common is situation above, but generally, `var (x,n) = xn` where xn is a tensor with 2-nd always-null, can be)
+GNU_ATTRIBUTE_NORETURN GNU_ATTRIBUTE_COLD
+static void fire_error_assign_always_null_to_variable(SrcLocation loc, const LocalVarData* assigned_var, bool is_assigned_null_literal) {
+ std::string var_name = assigned_var->name;
+ throw ParseError(loc, "can not infer type of `" + var_name + "`, it's always null; specify its type with `" + var_name + ": <type>`" + (is_assigned_null_literal ? " or use `null as <type>`" : ""));
+}
+
+// fire an error on `!cell` / `+slice`
+GNU_ATTRIBUTE_NORETURN GNU_ATTRIBUTE_COLD
+static void fire_error_cannot_apply_operator(SrcLocation loc, std::string_view operator_name, AnyExprV unary_expr) {
+ std::string op = static_cast<std::string>(operator_name);
+ throw ParseError(loc, "can not apply operator `" + op + "` to " + to_string(unary_expr->inferred_type));
+}
+
+// fire an error on `int + cell` / `slice & int`
+GNU_ATTRIBUTE_NORETURN GNU_ATTRIBUTE_COLD
+static void fire_error_cannot_apply_operator(SrcLocation loc, std::string_view operator_name, AnyExprV lhs, AnyExprV rhs) {
+ std::string op = static_cast<std::string>(operator_name);
+ throw ParseError(loc, "can not apply operator `" + op + "` to " + to_string(lhs->inferred_type) + " and " + to_string(rhs->inferred_type));
+}
+
+// check correctness of called arguments counts and their type matching
+static void check_function_arguments(const FunctionData* fun_ref, V<ast_argument_list> v, AnyExprV lhs_of_dot_call) {
+ int delta_self = lhs_of_dot_call ? 1 : 0;
+ int n_arguments = v->size() + delta_self;
+ int n_parameters = fun_ref->get_num_params();
+
+ // Tolk doesn't have optional parameters currently, so just compare counts
+ if (!n_parameters && lhs_of_dot_call) {
+ v->error("`" + fun_ref->name + "` has no parameters and can not be called as method");
+ }
+ if (n_parameters < n_arguments) {
+ v->error("too many arguments in call to `" + fun_ref->name + "`, expected " + std::to_string(n_parameters - delta_self) + ", have " + std::to_string(n_arguments - delta_self));
+ }
+ if (n_arguments < n_parameters) {
+ v->error("too few arguments in call to `" + fun_ref->name + "`, expected " + std::to_string(n_parameters - delta_self) + ", have " + std::to_string(n_arguments - delta_self));
+ }
+
+ if (lhs_of_dot_call) {
+ if (!fun_ref->parameters[0].declared_type->can_rhs_be_assigned(lhs_of_dot_call->inferred_type)) {
+ lhs_of_dot_call->error("can not call method for " + to_string(fun_ref->parameters[0]) + " with object of type " + to_string(lhs_of_dot_call));
+ }
+ }
+ for (int i = 0; i < v->size(); ++i) {
+ if (!fun_ref->parameters[i + delta_self].declared_type->can_rhs_be_assigned(v->get_arg(i)->inferred_type)) {
+ v->get_arg(i)->error("can not pass " + to_string(v->get_arg(i)) + " to " + to_string(fun_ref->parameters[i + delta_self]));
+ }
+ }
+}
+
+/*
+ * TypeInferringUnifyStrategy unifies types from various branches to a common result (lca).
+ * It's used to auto infer function return type based on return statements, like in TypeScript.
+ * Example: `fun f() { ... return 1; ... return null; }` inferred as `int`.
+ *
+ * Besides function returns, it's also useful for ternary `return cond ? 1 : null` and `match` expression.
+ * If types can't be unified (a function returns int and cell, for example), `unify()` returns false, handled outside.
+ * BTW, don't confuse this way of inferring with Hindley-Milner, they have nothing in common.
+ */
+class TypeInferringUnifyStrategy {
+ TypePtr unified_result = nullptr;
+
+ static TypePtr calculate_type_lca(TypePtr t1, TypePtr t2) {
+ if (t1 == t2) {
+ return t1;
+ }
+ if (t1->can_rhs_be_assigned(t2)) {
+ return t1;
+ }
+ if (t2->can_rhs_be_assigned(t1)) {
+ return t2;
+ }
+
+ const auto* tensor1 = t1->try_as<TypeDataTensor>();
+ const auto* tensor2 = t2->try_as<TypeDataTensor>();
+ if (tensor1 && tensor2 && tensor1->size() == tensor2->size()) {
+ std::vector<TypePtr> types_lca;
+ types_lca.reserve(tensor1->size());
+ for (int i = 0; i < tensor1->size(); ++i) {
+ TypePtr next = calculate_type_lca(tensor1->items[i], tensor2->items[i]);
+ if (next == nullptr) {
+ return nullptr;
+ }
+ types_lca.push_back(next);
+ }
+ return TypeDataTensor::create(std::move(types_lca));
+ }
+
+ const auto* tuple1 = t1->try_as<TypeDataTypedTuple>();
+ const auto* tuple2 = t2->try_as<TypeDataTypedTuple>();
+ if (tuple1 && tuple2 && tuple1->size() == tuple2->size()) {
+ std::vector<TypePtr> types_lca;
+ types_lca.reserve(tuple1->size());
+ for (int i = 0; i < tuple1->size(); ++i) {
+ TypePtr next = calculate_type_lca(tuple1->items[i], tuple2->items[i]);
+ if (next == nullptr) {
+ return nullptr;
+ }
+ types_lca.push_back(next);
+ }
+ return TypeDataTypedTuple::create(std::move(types_lca));
+ }
+
+ return nullptr;
+ }
+
+public:
+ bool unify_with(TypePtr next) {
+ if (unified_result == nullptr) {
+ unified_result = next;
+ return true;
+ }
+ if (unified_result == next) {
+ return true;
+ }
+
+ TypePtr combined = calculate_type_lca(unified_result, next);
+ if (!combined) {
+ return false;
+ }
+
+ unified_result = combined;
+ return true;
+ }
+
+ bool unify_with_implicit_return_void() {
+ if (unified_result == nullptr) {
+ unified_result = TypeDataVoid::create();
+ return true;
+ }
+
+ return unified_result == TypeDataVoid::create();
+ }
+
+ TypePtr get_result() const { return unified_result; }
+};
+
+/*
+ * This class handles all types of AST vertices and traverses them, filling all AnyExprV::inferred_type.
+ * Note, that it isn't derived from ASTVisitor, it has manual `switch` over all existing vertex types.
+ * There are two reasons for this:
+ * 1) when a new AST node type is introduced, I want it to fail here, not to be left un-inferred with UB at next steps
+ * 2) easy to maintain a hint (see comments at the top of the file)
+ */
+class InferCheckTypesAndCallsAndFieldsVisitor final {
+ const FunctionData* current_function = nullptr;
+ TypeInferringUnifyStrategy return_unifier;
+
+ GNU_ATTRIBUTE_ALWAYS_INLINE
+ static void assign_inferred_type(AnyExprV dst, AnyExprV src) {
+#ifdef TOLK_DEBUG
+ tolk_assert(src->inferred_type != nullptr && !src->inferred_type->has_unresolved_inside() && !src->inferred_type->has_genericT_inside());
+#endif
+ dst->mutate()->assign_inferred_type(src->inferred_type);
+ }
+
+ GNU_ATTRIBUTE_ALWAYS_INLINE
+ static void assign_inferred_type(AnyExprV dst, TypePtr inferred_type) {
+#ifdef TOLK_DEBUG
+ tolk_assert(inferred_type != nullptr && !inferred_type->has_unresolved_inside() && !inferred_type->has_genericT_inside());
+#endif
+ dst->mutate()->assign_inferred_type(inferred_type);
+ }
+
+ static void assign_inferred_type(const LocalVarData* local_var_or_param, TypePtr inferred_type) {
+#ifdef TOLK_DEBUG
+ tolk_assert(inferred_type != nullptr && !inferred_type->has_unresolved_inside() && !inferred_type->has_genericT_inside());
+#endif
+ local_var_or_param->mutate()->assign_inferred_type(inferred_type);
+ }
+
+ static void assign_inferred_type(const FunctionData* fun_ref, TypePtr inferred_return_type, TypePtr inferred_full_type) {
+#ifdef TOLK_DEBUG
+ tolk_assert(inferred_return_type != nullptr && !inferred_return_type->has_unresolved_inside() && !inferred_return_type->has_genericT_inside());
+#endif
+ fun_ref->mutate()->assign_inferred_type(inferred_return_type, inferred_full_type);
+ }
+
+ // traverse children in any statement
+ void process_any_statement(AnyV v) {
+ switch (v->type) {
+ case ast_sequence:
+ return process_sequence(v->as<ast_sequence>());
+ case ast_return_statement:
+ return process_return_statement(v->as<ast_return_statement>());
+ case ast_if_statement:
+ return process_if_statement(v->as<ast_if_statement>());
+ case ast_repeat_statement:
+ return process_repeat_statement(v->as<ast_repeat_statement>());
+ case ast_while_statement:
+ return process_while_statement(v->as<ast_while_statement>());
+ case ast_do_while_statement:
+ return process_do_while_statement(v->as<ast_do_while_statement>());
+ case ast_throw_statement:
+ return process_throw_statement(v->as<ast_throw_statement>());
+ case ast_assert_statement:
+ return process_assert_statement(v->as<ast_assert_statement>());
+ case ast_try_catch_statement:
+ return process_try_catch_statement(v->as<ast_try_catch_statement>());
+ case ast_empty_statement:
+ return;
+ default:
+ infer_any_expr(reinterpret_cast<AnyExprV>(v));
+ }
+ }
+
+ // assigns inferred_type for any expression (by calling assign_inferred_type)
+ void infer_any_expr(AnyExprV v, TypePtr hint = nullptr) {
+ switch (v->type) {
+ case ast_int_const:
+ return infer_int_const(v->as<ast_int_const>());
+ case ast_string_const:
+ return infer_string_const(v->as<ast_string_const>());
+ case ast_bool_const:
+ return infer_bool_const(v->as<ast_bool_const>());
+ case ast_local_vars_declaration:
+ return infer_local_vars_declaration(v->as<ast_local_vars_declaration>());
+ case ast_assign:
+ return infer_assignment(v->as<ast_assign>());
+ case ast_set_assign:
+ return infer_set_assign(v->as<ast_set_assign>());
+ case ast_unary_operator:
+ return infer_unary_operator(v->as<ast_unary_operator>());
+ case ast_binary_operator:
+ return infer_binary_operator(v->as<ast_binary_operator>());
+ case ast_ternary_operator:
+ return infer_ternary_operator(v->as<ast_ternary_operator>(), hint);
+ case ast_cast_as_operator:
+ return infer_cast_as_operator(v->as<ast_cast_as_operator>());
+ case ast_parenthesized_expression:
+ return infer_parenthesized(v->as<ast_parenthesized_expression>(), hint);
+ case ast_reference:
+ return infer_reference(v->as<ast_reference>());
+ case ast_dot_access:
+ return infer_dot_access(v->as<ast_dot_access>(), hint);
+ case ast_function_call:
+ return infer_function_call(v->as<ast_function_call>(), hint);
+ case ast_tensor:
+ return infer_tensor(v->as<ast_tensor>(), hint);
+ case ast_typed_tuple:
+ return infer_typed_tuple(v->as<ast_typed_tuple>(), hint);
+ case ast_null_keyword:
+ return infer_null_keyword(v->as<ast_null_keyword>());
+ case ast_underscore:
+ return infer_underscore(v->as<ast_underscore>(), hint);
+ case ast_empty_expression:
+ return infer_empty_expression(v->as<ast_empty_expression>());
+ default:
+ throw UnexpectedASTNodeType(v, "infer_any_expr");
+ }
+ }
+
+ static bool expect_integer(AnyExprV v_inferred) {
+ return v_inferred->inferred_type == TypeDataInt::create();
+ }
+
+ static bool expect_boolean(AnyExprV v_inferred) {
+ return v_inferred->inferred_type == TypeDataBool::create();
+ }
+
+ static void infer_int_const(V<ast_int_const> v) {
+ assign_inferred_type(v, TypeDataInt::create());
+ }
+
+ static void infer_string_const(V<ast_string_const> v) {
+ if (v->is_bitslice()) {
+ assign_inferred_type(v, TypeDataSlice::create());
+ } else {
+ assign_inferred_type(v, TypeDataInt::create());
+ }
+ }
+
+ static void infer_bool_const(V<ast_bool_const> v) {
+ assign_inferred_type(v, TypeDataBool::create());
+ }
+
+ static void infer_local_vars_declaration(V<ast_local_vars_declaration>) {
+ // it can not appear as a standalone expression
+ // `var ... = rhs` is handled by ast_assign
+ tolk_assert(false);
+ }
+
+ void infer_assignment(V<ast_assign> v) {
+ // v is assignment: `x = 5` / `var x = 5` / `var x: slice = 5` / `(cs,_) = f()` / `val (a,[b],_) = (a,t,0)`
+ // it's a tricky node to handle, because to infer rhs, at first we need to create hint from lhs
+ // and then to apply/check inferred rhs onto lhs
+ // about a hint: `var i: int = t.tupleAt(0)` is ok, but `var i = t.tupleAt(0)` not, since `tupleAt<T>(t,i): T`
+ AnyExprV lhs = v->get_lhs();
+ AnyExprV rhs = v->get_rhs();
+ infer_any_expr(rhs, calc_hint_from_assignment_lhs(lhs));
+ process_assignment_lhs_after_infer_rhs(lhs, rhs->inferred_type, rhs);
+ assign_inferred_type(v, lhs);
+ }
+
+ // having assignment like `var (i: int, s) = rhs` (its lhs is local vars declaration),
+ // create a contextual infer hint for rhs, `(int, unknown)` in this case
+ // this hint helps to deduce generics and to resolve unknown types while inferring rhs
+ static TypePtr calc_hint_from_assignment_lhs(AnyExprV lhs) {
+ // `var ... = rhs` - dig into left part
+ if (auto lhs_decl = lhs->try_as<ast_local_vars_declaration>()) {
+ return calc_hint_from_assignment_lhs(lhs_decl->get_expr());
+ }
+
+ // inside `var v: int = rhs` / `var _ = rhs` / `var v redef = rhs` (lhs is "v" / "_" / "v")
+ if (auto lhs_var = lhs->try_as<ast_local_var_lhs>()) {
+ if (lhs_var->marked_as_redef) {
+ return lhs_var->var_ref->declared_type;
+ }
+ if (lhs_var->declared_type) {
+ return lhs_var->declared_type;
+ }
+ return TypeDataUnknown::create();
+ }
+
+ // `v = rhs` / `(c1, c2) = rhs` (lhs is "v" / "_" / "c1" / "c2" after recursion)
+ if (auto lhs_ref = lhs->try_as<ast_reference>()) {
+ if (const auto* var_ref = lhs_ref->sym->try_as<LocalVarData>()) {
+ return var_ref->declared_type;
+ }
+ if (const auto* glob_ref = lhs_ref->sym->try_as<GlobalVarData>()) {
+ return glob_ref->declared_type;
+ }
+ return TypeDataUnknown::create();
+ }
+
+ // `(v1, v2) = rhs` / `var (v1, v2) = rhs`
+ if (auto lhs_tensor = lhs->try_as<ast_tensor>()) {
+ std::vector<TypePtr> sub_hints;
+ sub_hints.reserve(lhs_tensor->size());
+ for (AnyExprV item : lhs_tensor->get_items()) {
+ sub_hints.push_back(calc_hint_from_assignment_lhs(item));
+ }
+ return TypeDataTensor::create(std::move(sub_hints));
+ }
+
+ // `[v1, v2] = rhs` / `var [v1, v2] = rhs`
+ if (auto lhs_tuple = lhs->try_as<ast_typed_tuple>()) {
+ std::vector<TypePtr> sub_hints;
+ sub_hints.reserve(lhs_tuple->size());
+ for (AnyExprV item : lhs_tuple->get_items()) {
+ sub_hints.push_back(calc_hint_from_assignment_lhs(item));
+ }
+ return TypeDataTypedTuple::create(std::move(sub_hints));
+ }
+
+ return TypeDataUnknown::create();
+ }
+
+ // handle (and dig recursively) into `var lhs = rhs`
+ // examples: `var z = 5`, `var (x, [y]) = (2, [3])`, `var (x, [y]) = xy`
+ // while recursing, keep track of rhs if lhs and rhs have common shape (5 for z, 2 for x, [3] for [y], 3 for y)
+ // (so that on type mismatch, point to corresponding rhs, example: `var (x, y:slice) = (1, 2)` point to 2
+ void process_assignment_lhs_after_infer_rhs(AnyExprV lhs, TypePtr rhs_type, AnyExprV corresponding_maybe_rhs) {
+ AnyExprV err_loc = corresponding_maybe_rhs ? corresponding_maybe_rhs : lhs;
+
+ // `var ... = rhs` - dig into left part
+ if (auto lhs_decl = lhs->try_as<ast_local_vars_declaration>()) {
+ process_assignment_lhs_after_infer_rhs(lhs_decl->get_expr(), rhs_type, corresponding_maybe_rhs);
+ assign_inferred_type(lhs, lhs_decl->get_expr()->inferred_type);
+ return;
+ }
+
+ // inside `var v: int = rhs` / `var _ = rhs` / `var v redef = rhs` (lhs is "v" / "_" / "v")
+ if (auto lhs_var = lhs->try_as<ast_local_var_lhs>()) {
+ TypePtr declared_type = lhs_var->declared_type; // `var v: int = rhs` (otherwise, nullptr)
+ if (lhs_var->marked_as_redef) {
+ tolk_assert(lhs_var->var_ref && lhs_var->var_ref->declared_type);
+ declared_type = lhs_var->var_ref->declared_type;
+ }
+ if (declared_type) {
+ if (!declared_type->can_rhs_be_assigned(rhs_type)) {
+ err_loc->error("can not assign " + to_string(rhs_type) + " to variable of type " + to_string(declared_type));
+ }
+ assign_inferred_type(lhs, declared_type);
+ } else {
+ if (rhs_type == TypeDataNullLiteral::create()) {
+ fire_error_assign_always_null_to_variable(err_loc->loc, lhs_var->var_ref->try_as<LocalVarData>(), corresponding_maybe_rhs && corresponding_maybe_rhs->type == ast_null_keyword);
+ }
+ assign_inferred_type(lhs, rhs_type);
+ assign_inferred_type(lhs_var->var_ref, lhs_var->inferred_type);
+ }
+ return;
+ }
+
+ // `v = rhs` / `(c1, c2) = rhs` (lhs is "v" / "_" / "c1" / "c2" after recursion)
+ if (lhs->try_as<ast_reference>()) {
+ infer_any_expr(lhs);
+ if (!lhs->inferred_type->can_rhs_be_assigned(rhs_type)) {
+ err_loc->error("can not assign " + to_string(rhs_type) + " to variable of type " + to_string(lhs));
+ }
+ return;
+ }
+
+ // `(v1, v2) = rhs` / `var (v1, v2) = rhs` (rhs may be `(1,2)` or `tensorVar` or `someF()`, doesn't matter)
+ // dig recursively into v1 and v2 with corresponding rhs i-th item of a tensor
+ if (auto lhs_tensor = lhs->try_as<ast_tensor>()) {
+ const TypeDataTensor* rhs_type_tensor = rhs_type->try_as<TypeDataTensor>();
+ if (!rhs_type_tensor) {
+ err_loc->error("can not assign " + to_string(rhs_type) + " to a tensor");
+ }
+ if (lhs_tensor->size() != rhs_type_tensor->size()) {
+ err_loc->error("can not assign " + to_string(rhs_type) + ", sizes mismatch");
+ }
+ V<ast_tensor> rhs_tensor_maybe = corresponding_maybe_rhs ? corresponding_maybe_rhs->try_as<ast_tensor>() : nullptr;
+ std::vector<TypePtr> types_list;
+ types_list.reserve(lhs_tensor->size());
+ for (int i = 0; i < lhs_tensor->size(); ++i) {
+ process_assignment_lhs_after_infer_rhs(lhs_tensor->get_item(i), rhs_type_tensor->items[i], rhs_tensor_maybe ? rhs_tensor_maybe->get_item(i) : nullptr);
+ types_list.push_back(lhs_tensor->get_item(i)->inferred_type);
+ }
+ assign_inferred_type(lhs, TypeDataTensor::create(std::move(types_list)));
+ return;
+ }
+
+ // `[v1, v2] = rhs` / `var [v1, v2] = rhs` (rhs may be `[1,2]` or `tupleVar` or `someF()`, doesn't matter)
+ // dig recursively into v1 and v2 with corresponding rhs i-th item of a tuple
+ if (auto lhs_tuple = lhs->try_as<ast_typed_tuple>()) {
+ const TypeDataTypedTuple* rhs_type_tuple = rhs_type->try_as<TypeDataTypedTuple>();
+ if (!rhs_type_tuple) {
+ err_loc->error("can not assign " + to_string(rhs_type) + " to a tuple");
+ }
+ if (lhs_tuple->size() != rhs_type_tuple->size()) {
+ err_loc->error("can not assign " + to_string(rhs_type) + ", sizes mismatch");
+ }
+ V<ast_typed_tuple> rhs_tuple_maybe = corresponding_maybe_rhs ? corresponding_maybe_rhs->try_as<ast_typed_tuple>() : nullptr;
+ std::vector<TypePtr> types_list;
+ types_list.reserve(lhs_tuple->size());
+ for (int i = 0; i < lhs_tuple->size(); ++i) {
+ process_assignment_lhs_after_infer_rhs(lhs_tuple->get_item(i), rhs_type_tuple->items[i], rhs_tuple_maybe ? rhs_tuple_maybe->get_item(i) : nullptr);
+ types_list.push_back(lhs_tuple->get_item(i)->inferred_type);
+ }
+ assign_inferred_type(lhs, TypeDataTypedTuple::create(std::move(types_list)));
+ return;
+ }
+
+ // `_ = rhs`
+ if (lhs->type == ast_underscore) {
+ assign_inferred_type(lhs, TypeDataUnknown::create());
+ return;
+ }
+
+ // here is something strange and unhandled, like `f() = rhs`
+ // it will fail on later compilation steps (like rvalue/lvalue checks), but type inferring should pass
+ infer_any_expr(lhs, rhs_type);
+ if (!lhs->inferred_type->can_rhs_be_assigned(rhs_type)) {
+ err_loc->error("can not assign " + to_string(rhs_type) + " to " + to_string(lhs));
+ }
+ }
+
+ void infer_set_assign(V<ast_set_assign> v) {
+ AnyExprV lhs = v->get_lhs();
+ AnyExprV rhs = v->get_rhs();
+ infer_any_expr(lhs);
+ infer_any_expr(rhs, lhs->inferred_type);
+
+ // almost all operators implementation is hardcoded by built-in functions `_+_` and similar
+ std::string_view builtin_func = v->operator_name; // "+" for operator +=
+
+ switch (v->tok) {
+ // &= |= ^= are "overloaded" both for integers and booleans, (int &= bool) is NOT allowed
+ case tok_set_bitwise_and:
+ case tok_set_bitwise_or:
+ case tok_set_bitwise_xor: {
+ bool both_int = expect_integer(lhs) && expect_integer(rhs);
+ bool both_bool = expect_boolean(lhs) && expect_boolean(rhs);
+ if (!both_int && !both_bool) {
+ fire_error_cannot_apply_operator(v->loc, v->operator_name, lhs, rhs);
+ }
+ break;
+ }
+ // others are mathematical: += *= ...
+ default:
+ if (!expect_integer(lhs) || !expect_integer(rhs)) {
+ fire_error_cannot_apply_operator(v->loc, v->operator_name, lhs, rhs);
+ }
+ }
+
+ assign_inferred_type(v, lhs);
+ if (!builtin_func.empty()) {
+ const FunctionData* builtin_sym = lookup_global_symbol("_" + static_cast<std::string>(builtin_func) + "_")->as<FunctionData>();
+ tolk_assert(builtin_sym);
+ v->mutate()->assign_fun_ref(builtin_sym);
+ }
+ }
+
+ void infer_unary_operator(V<ast_unary_operator> v) {
+ AnyExprV rhs = v->get_rhs();
+ infer_any_expr(rhs);
+
+ // all operators implementation is hardcoded by built-in functions `~_` and similar
+ std::string_view builtin_func = v->operator_name;
+
+ switch (v->tok) {
+ case tok_minus:
+ case tok_plus:
+ case tok_bitwise_not:
+ if (!expect_integer(rhs)) {
+ fire_error_cannot_apply_operator(v->loc, v->operator_name, rhs);
+ }
+ assign_inferred_type(v, TypeDataInt::create());
+ break;
+ case tok_logical_not:
+ if (expect_boolean(rhs)) {
+ builtin_func = "!b"; // "overloaded" for bool
+ } else if (!expect_integer(rhs)) {
+ fire_error_cannot_apply_operator(v->loc, v->operator_name, rhs);
+ }
+ assign_inferred_type(v, TypeDataBool::create());
+ break;
+ default:
+ tolk_assert(false);
+ }
+
+ if (!builtin_func.empty()) {
+ const FunctionData* builtin_sym = lookup_global_symbol(static_cast<std::string>(builtin_func) + "_")->as<FunctionData>();
+ tolk_assert(builtin_sym);
+ v->mutate()->assign_fun_ref(builtin_sym);
+ }
+ }
+
+ void infer_binary_operator(V<ast_binary_operator> v) {
+ AnyExprV lhs = v->get_lhs();
+ AnyExprV rhs = v->get_rhs();
+ infer_any_expr(lhs);
+ infer_any_expr(rhs);
+
+ // almost all operators implementation is hardcoded by built-in functions `_+_` and similar
+ std::string_view builtin_func = v->operator_name;
+
+ switch (v->tok) {
+ // == != can compare both integers and booleans, (int == bool) is NOT allowed
+ case tok_eq:
+ case tok_neq: {
+ bool both_int = expect_integer(lhs) && expect_integer(rhs);
+ bool both_bool = expect_boolean(lhs) && expect_boolean(rhs);
+ if (!both_int && !both_bool) {
+ if (lhs->inferred_type == rhs->inferred_type) { // compare slice with slice
+ v->error("type " + to_string(lhs) + " can not be compared with `== !=`");
+ } else {
+ fire_error_cannot_apply_operator(v->loc, v->operator_name, lhs, rhs);
+ }
+ }
+ assign_inferred_type(v, TypeDataBool::create());
+ break;
+ }
+ // < > can compare only integers
+ case tok_lt:
+ case tok_gt:
+ case tok_leq:
+ case tok_geq:
+ case tok_spaceship: {
+ if (!expect_integer(lhs) || !expect_integer(rhs)) {
+ fire_error_cannot_apply_operator(v->loc, v->operator_name, lhs, rhs);
+ }
+ assign_inferred_type(v, TypeDataBool::create());
+ break;
+ }
+ // & | ^ are "overloaded" both for integers and booleans, (int & bool) is NOT allowed
+ case tok_bitwise_and:
+ case tok_bitwise_or:
+ case tok_bitwise_xor: {
+ bool both_int = expect_integer(lhs) && expect_integer(rhs);
+ bool both_bool = expect_boolean(lhs) && expect_boolean(rhs);
+ if (!both_int && !both_bool) {
+ fire_error_cannot_apply_operator(v->loc, v->operator_name, lhs, rhs);
+ }
+ assign_inferred_type(v, rhs); // (int & int) is int, (bool & bool) is bool
+ break;
+ }
+ // && || can work with integers and booleans, (int && bool) is allowed
+ case tok_logical_and:
+ case tok_logical_or: {
+ bool lhs_ok = expect_integer(lhs) || expect_boolean(lhs);
+ bool rhs_ok = expect_integer(rhs) || expect_boolean(rhs);
+ if (!lhs_ok || !rhs_ok) {
+ fire_error_cannot_apply_operator(v->loc, v->operator_name, lhs, rhs);
+ }
+ assign_inferred_type(v, TypeDataBool::create());
+ builtin_func = {}; // no built-in functions, logical operators are expressed as IFs at IR level
+ break;
+ }
+ // others are mathematical: + * ...
+ default:
+ if (!expect_integer(lhs) || !expect_integer(rhs)) {
+ fire_error_cannot_apply_operator(v->loc, v->operator_name, lhs, rhs);
+ }
+ assign_inferred_type(v, TypeDataInt::create());
+ }
+
+ if (!builtin_func.empty()) {
+ const FunctionData* builtin_sym = lookup_global_symbol("_" + static_cast<std::string>(builtin_func) + "_")->as<FunctionData>();
+ tolk_assert(builtin_sym);
+ v->mutate()->assign_fun_ref(builtin_sym);
+ }
+ }
+
+ void infer_ternary_operator(V<ast_ternary_operator> v, TypePtr hint) {
+ AnyExprV cond = v->get_cond();
+ infer_any_expr(cond);
+ if (!expect_integer(cond) && !expect_boolean(cond)) {
+ cond->error("can not use " + to_string(cond) + " as a boolean condition");
+ }
+ infer_any_expr(v->get_when_true(), hint);
+ infer_any_expr(v->get_when_false(), hint);
+
+ TypeInferringUnifyStrategy tern_type;
+ tern_type.unify_with(v->get_when_true()->inferred_type);
+ if (!tern_type.unify_with(v->get_when_false()->inferred_type)) {
+ v->error("types of ternary branches are incompatible");
+ }
+ assign_inferred_type(v, tern_type.get_result());
+ }
+
+ void infer_cast_as_operator(V<ast_cast_as_operator> v) {
+ // for `expr as <type>`, use this type for hint, so that `t.tupleAt(0) as int` is ok
+ infer_any_expr(v->get_expr(), v->cast_to_type);
+ if (!v->get_expr()->inferred_type->can_be_casted_with_as_operator(v->cast_to_type)) {
+ v->error("type " + to_string(v->get_expr()) + " can not be cast to " + to_string(v->cast_to_type));
+ }
+ assign_inferred_type(v, v->cast_to_type);
+ }
+
+ void infer_parenthesized(V<ast_parenthesized_expression> v, TypePtr hint) {
+ infer_any_expr(v->get_expr(), hint);
+ assign_inferred_type(v, v->get_expr());
+ }
+
+ static void infer_reference(V<ast_reference> v) {
+ if (const auto* var_ref = v->sym->try_as<LocalVarData>()) {
+ assign_inferred_type(v, var_ref->declared_type);
+
+ } else if (const auto* const_ref = v->sym->try_as<GlobalConstData>()) {
+ assign_inferred_type(v, const_ref->is_int_const() ? TypeDataInt::create() : TypeDataSlice::create());
+
+ } else if (const auto* glob_ref = v->sym->try_as<GlobalVarData>()) {
+ assign_inferred_type(v, glob_ref->declared_type);
+
+ } else if (const auto* fun_ref = v->sym->try_as<FunctionData>()) {
+ // it's `globalF` / `globalF<int>` - references to functions used as non-call
+ V<ast_instantiationT_list> v_instantiationTs = v->get_instantiationTs();
+
+ if (fun_ref->is_generic_function() && !v_instantiationTs) {
+ // `genericFn` is invalid as non-call, can't be used without <instantiation>
+ v->error("can not use a generic function " + to_string(fun_ref) + " as non-call");
+
+ } else if (fun_ref->is_generic_function()) {
+ // `genericFn<int>` is valid, it's a reference to instantiation
+ std::vector<TypePtr> substitutions = collect_fun_generic_substitutions_from_manually_specified(v->loc, fun_ref, v_instantiationTs);
+ fun_ref = check_and_instantiate_generic_function(v->loc, fun_ref, std::move(substitutions));
+ v->mutate()->assign_sym(fun_ref);
+
+ } else if (UNLIKELY(v_instantiationTs != nullptr)) {
+ // non-generic function referenced like `return beginCell<builder>;`
+ v_instantiationTs->error("not generic function used with generic T");
+ }
+
+ fun_ref->mutate()->assign_is_used_as_noncall();
+ get_or_infer_return_type(fun_ref);
+ assign_inferred_type(v, fun_ref->inferred_full_type);
+ return;
+
+ } else {
+ tolk_assert(false);
+ }
+
+ // for non-functions: `local_var<int>` and similar not allowed
+ if (UNLIKELY(v->has_instantiationTs())) {
+ v->get_instantiationTs()->error("generic T not expected here");
+ }
+ }
+
+ // given `genericF<int, slice>` / `t.tupleFirst<cell>` (the user manually specified instantiation Ts),
+ // validate and collect them
+ // returns: [int, slice] / [cell]
+ static std::vector<TypePtr> collect_fun_generic_substitutions_from_manually_specified(SrcLocation loc, const FunctionData* fun_ref, V<ast_instantiationT_list> instantiationT_list) {
+ if (fun_ref->genericTs->size() != instantiationT_list->get_items().size()) {
+ throw ParseError(loc, "wrong count of generic T: expected " + std::to_string(fun_ref->genericTs->size()) + ", got " + std::to_string(instantiationT_list->size()));
+ }
+
+ std::vector<TypePtr> substitutions;
+ substitutions.reserve(instantiationT_list->size());
+ for (int i = 0; i < instantiationT_list->size(); ++i) {
+ substitutions.push_back(instantiationT_list->get_item(i)->substituted_type);
+ }
+
+ return substitutions;
+ }
+
+ // when generic Ts have been collected from user-specified or deduced from arguments,
+ // instantiate a generic function
+ // example: was `t.tuplePush(2)`, deduced <int>, instantiate `tuplePush<int>`
+ // example: was `t.tuplePush<slice>(2)`, read <slice>, instantiate `tuplePush<slice>` (will later fail type check)
+ // example: was `var cb = t.tupleFirst<int>;` (used as reference, as non-call), instantiate `tupleFirst<int>`
+ // returns fun_ref to instantiated function
+ static const FunctionData* check_and_instantiate_generic_function(SrcLocation loc, const FunctionData* fun_ref, std::vector<TypePtr>&& substitutionTs) {
+ // T for asm function must be a TVM primitive (width 1), otherwise, asm would act incorrectly
+ if (fun_ref->is_asm_function() || fun_ref->is_builtin_function()) {
+ for (int i = 0; i < static_cast<int>(substitutionTs.size()); ++i) {
+ if (substitutionTs[i]->calc_width_on_stack() != 1) {
+ fire_error_calling_asm_function_with_non1_stack_width_arg(loc, fun_ref, substitutionTs, i);
+ }
+ }
+ }
+
+ std::string inst_name = generate_instantiated_name(fun_ref->name, substitutionTs);
+ try {
+ // make deep clone of `f<T>` with substitutionTs
+ // (if `f<int>` was already instantiated, it will be immediately returned from a symbol table)
+ return instantiate_generic_function(loc, fun_ref, inst_name, std::move(substitutionTs));
+ } catch (const ParseError& ex) {
+ throw ParseError(ex.where, "while instantiating generic function `" + inst_name + "` at " + loc.to_string() + ": " + ex.message);
+ }
+ }
+
+ void infer_dot_access(V<ast_dot_access> v, TypePtr hint) {
+ // it's NOT a method call `t.tupleSize()` (since such cases are handled by infer_function_call)
+ // it's `t.0`, `getUser().id`, and `t.tupleSize` (as a reference, not as a call)
+ infer_any_expr(v->get_obj());
+ // our goal is to fill v->target knowing type of obj
+ V<ast_identifier> v_ident = v->get_identifier(); // field/method name vertex
+ V<ast_instantiationT_list> v_instantiationTs = v->get_instantiationTs();
+ std::string_view field_name = v_ident->name;
+
+ // for now, Tolk doesn't have structures, properties, and object-scoped methods
+ // so, only `t.tupleSize` is allowed, look up a global function
+ const Symbol* sym = lookup_global_symbol(field_name);
+ if (!sym) {
+ v_ident->error("undefined symbol `" + static_cast<std::string>(field_name) + "`");
+ }
+ const FunctionData* fun_ref = sym->try_as<FunctionData>();
+ if (!fun_ref) {
+ v_ident->error("referencing a non-function");
+ }
+
+ // `t.tupleSize` is ok, `cs.tupleSize` not
+ if (!fun_ref->parameters[0].declared_type->can_rhs_be_assigned(v->get_obj()->inferred_type)) {
+ v_ident->error("referencing a method for " + to_string(fun_ref->parameters[0]) + " with an object of type " + to_string(v->get_obj()));
+ }
+
+ if (fun_ref->is_generic_function() && !v_instantiationTs) {
+ // `genericFn` and `t.tupleAt` are invalid as non-call, they can't be used without <instantiation>
+ v->error("can not use a generic function " + to_string(fun_ref) + " as non-call");
+
+ } else if (fun_ref->is_generic_function()) {
+ // `t.tupleAt<slice>` is valid, it's a reference to instantiation
+ std::vector<TypePtr> substitutions = collect_fun_generic_substitutions_from_manually_specified(v->loc, fun_ref, v_instantiationTs);
+ fun_ref = check_and_instantiate_generic_function(v->loc, fun_ref, std::move(substitutions));
+
+ } else if (UNLIKELY(v_instantiationTs != nullptr)) {
+ // non-generic method referenced like `var cb = c.cellHash<int>;`
+ v_instantiationTs->error("not generic function used with generic T");
+ }
+
+ fun_ref->mutate()->assign_is_used_as_noncall();
+ v->mutate()->assign_target(fun_ref);
+ get_or_infer_return_type(fun_ref);
+ assign_inferred_type(v, fun_ref->inferred_full_type); // type of `t.tupleSize` is TypeDataFunCallable
+ }
+
+ void infer_function_call(V<ast_function_call> v, TypePtr hint) {
+ AnyExprV callee = v->get_callee();
+
+ // v is `globalF(args)` / `globalF<int>(args)` / `obj.method(args)` / `local_var(args)` / `getF()(args)`
+ int delta_self = 0;
+ AnyExprV dot_obj = nullptr;
+ const FunctionData* fun_ref = nullptr;
+ V<ast_instantiationT_list> v_instantiationTs = nullptr;
+
+ if (auto v_ref = callee->try_as<ast_reference>()) {
+ // `globalF()` / `globalF<int>()` / `local_var()` / `SOME_CONST()`
+ fun_ref = v_ref->sym->try_as<FunctionData>(); // not null for `globalF`
+ v_instantiationTs = v_ref->get_instantiationTs(); // present for `globalF<int>()`
+
+ } else if (auto v_dot = callee->try_as<ast_dot_access>()) {
+ // `obj.someMethod()` / `obj.someMethod<int>()` / `getF().someMethod()` / `obj.SOME_CONST()`
+ delta_self = 1;
+ dot_obj = v_dot->get_obj();
+ v_instantiationTs = v_dot->get_instantiationTs(); // present for `obj.someMethod<int>()`
+ infer_any_expr(dot_obj);
+
+ // for now, Tolk doesn't have object-scoped methods, so method resolving doesn't depend on obj type
+ // (in other words, `globalFunction(a)` = `a.globalFunction()`)
+ std::string_view method_name = v_dot->get_field_name();
+ const Symbol* sym = lookup_global_symbol(method_name);
+ if (!sym) {
+ v_dot->get_identifier()->error("undefined symbol `" + static_cast<std::string>(method_name) + "`");
+ }
+ fun_ref = sym->try_as<FunctionData>();
+ if (!fun_ref) {
+ v_dot->get_identifier()->error("calling a non-function");
+ }
+
+ } else {
+ // `getF()()` / `5()`
+ // fun_ref remains nullptr
+ }
+
+ // infer argument types, looking at fun_ref's parameters as hints
+ for (int i = 0; i < v->get_num_args(); ++i) {
+ TypePtr param_type = fun_ref && i < fun_ref->get_num_params() - delta_self ? fun_ref->parameters[delta_self + i].declared_type : nullptr;
+ auto arg_i = v->get_arg(i);
+ infer_any_expr(arg_i->get_expr(), param_type && !param_type->has_genericT_inside() ? param_type : nullptr);
+ assign_inferred_type(arg_i, arg_i->get_expr());
+ }
+
+ // handle `local_var()` / `getF()()` / `5()` / `SOME_CONST()` / `obj.method()()()`
+ if (!fun_ref) {
+ // treat callee like a usual expression, which must have "callable" inferred type
+ infer_any_expr(callee);
+ const TypeDataFunCallable* f_callable = callee->inferred_type->try_as<TypeDataFunCallable>();
+ if (!f_callable) { // `5()` / `SOME_CONST()` / `null()`
+ v->error("calling a non-function");
+ }
+ // check arguments count and their types
+ if (v->get_num_args() != static_cast<int>(f_callable->params_types.size())) {
+ v->error("expected " + std::to_string(f_callable->params_types.size()) + " arguments, got " + std::to_string(v->get_arg_list()->size()));
+ }
+ for (int i = 0; i < v->get_num_args(); ++i) {
+ if (!f_callable->params_types[i]->can_rhs_be_assigned(v->get_arg(i)->inferred_type)) {
+ v->get_arg(i)->error("can not pass " + to_string(v->get_arg(i)) + " to " + to_string(f_callable->params_types[i]));
+ }
+ }
+ v->mutate()->assign_fun_ref(nullptr); // no fun_ref to a global function
+ assign_inferred_type(v, f_callable->return_type);
+ return;
+ }
+
+ // so, we have a call `f(args)` or `obj.f(args)`, f is a global function (fun_ref) (code / asm / builtin)
+ // if it's a generic function `f<T>`, we need to instantiate it, like `f<int>`
+ // same for generic methods `t.tupleAt<T>`, need to achieve `t.tupleAt<int>`
+
+ if (fun_ref->is_generic_function() && v_instantiationTs) {
+ // if Ts are specified by a user like `f<int>(args)` / `t.tupleAt<slice>()`, take them
+ std::vector<TypePtr> substitutions = collect_fun_generic_substitutions_from_manually_specified(v->loc, fun_ref, v_instantiationTs);
+ fun_ref = check_and_instantiate_generic_function(v->loc, fun_ref, std::move(substitutions));
+
+ } else if (fun_ref->is_generic_function()) {
+ // if `f<T>` called like `f(args)`, deduce T from arg types
+ std::vector<TypePtr> arg_types;
+ arg_types.reserve(delta_self + v->get_num_args());
+ if (dot_obj) {
+ arg_types.push_back(dot_obj->inferred_type);
+ }
+ for (int i = 0; i < v->get_num_args(); ++i) {
+ arg_types.push_back(v->get_arg(i)->inferred_type);
+ }
+
+ td::Result<std::vector<TypePtr>> deduced = deduce_substitutionTs_on_generic_func_call(fun_ref, std::move(arg_types), hint);
+ if (deduced.is_error()) {
+ v->error(deduced.error().message().str() + " for generic function " + to_string(fun_ref));
+ }
+ fun_ref = check_and_instantiate_generic_function(v->loc, fun_ref, deduced.move_as_ok());
+
+ } else if (UNLIKELY(v_instantiationTs != nullptr)) {
+ // non-generic function/method called with type arguments, like `c.cellHash<int>()` / `beginCell<builder>()`
+ v_instantiationTs->error("calling a not generic function with generic T");
+ }
+
+ v->mutate()->assign_fun_ref(fun_ref);
+ // since for `t.tupleAt()`, infer_dot_access() not called for callee = "t.tupleAt", assign its target here
+ if (v->is_dot_call()) {
+ v->get_callee()->as<ast_dot_access>()->mutate()->assign_target(fun_ref);
+ v->get_callee()->as<ast_dot_access>()->mutate()->assign_inferred_type(fun_ref->inferred_full_type);
+ }
+ // check arguments count and their types
+ check_function_arguments(fun_ref, v->get_arg_list(), dot_obj);
+ // get return type either from user-specified declaration or infer here on demand traversing its body
+ get_or_infer_return_type(fun_ref);
+ TypePtr inferred_type = dot_obj && fun_ref->does_return_self() ? dot_obj->inferred_type : fun_ref->inferred_return_type;
+ assign_inferred_type(v, inferred_type);
+ assign_inferred_type(callee, fun_ref->inferred_full_type);
+ // note, that mutate params don't affect typing, they are handled when converting to IR
+ }
+
+ void infer_tensor(V<ast_tensor> v, TypePtr hint) {
+ const TypeDataTensor* tensor_hint = hint ? hint->try_as<TypeDataTensor>() : nullptr;
+ std::vector<TypePtr> types_list;
+ types_list.reserve(v->get_items().size());
+ for (int i = 0; i < v->size(); ++i) {
+ AnyExprV item = v->get_item(i);
+ infer_any_expr(item, tensor_hint && i < tensor_hint->size() ? tensor_hint->items[i] : nullptr);
+ types_list.emplace_back(item->inferred_type);
+ }
+ assign_inferred_type(v, TypeDataTensor::create(std::move(types_list)));
+ }
+
+ void infer_typed_tuple(V<ast_typed_tuple> v, TypePtr hint) {
+ const TypeDataTypedTuple* tuple_hint = hint ? hint->try_as<TypeDataTypedTuple>() : nullptr;
+ std::vector<TypePtr> types_list;
+ types_list.reserve(v->get_items().size());
+ for (int i = 0; i < v->size(); ++i) {
+ AnyExprV item = v->get_item(i);
+ infer_any_expr(item, tuple_hint && i < tuple_hint->size() ? tuple_hint->items[i] : nullptr);
+ types_list.emplace_back(item->inferred_type);
+ }
+ assign_inferred_type(v, TypeDataTypedTuple::create(std::move(types_list)));
+ }
+
+ static void infer_null_keyword(V<ast_null_keyword> v) {
+ assign_inferred_type(v, TypeDataNullLiteral::create());
+ }
+
+ static void infer_underscore(V<ast_underscore> v, TypePtr hint) {
+ // if execution is here, underscore is either used as lhs of assignment, or incorrectly, like `f(_)`
+ // more precise is to always set unknown here, but for incorrect usages, instead of an error
+ // "can not pass unknown to X" would better be an error it can't be used as a value, at later steps
+ assign_inferred_type(v, hint ? hint : TypeDataUnknown::create());
+ }
+
+ static void infer_empty_expression(V<ast_empty_expression> v) {
+ assign_inferred_type(v, TypeDataUnknown::create());
+ }
+
+ void process_sequence(V<ast_sequence> v) {
+ for (AnyV item : v->get_items()) {
+ process_any_statement(item);
+ }
+ }
+
+ static bool is_expr_valid_as_return_self(AnyExprV return_expr) {
+ // `return self`
+ if (return_expr->type == ast_reference && return_expr->as<ast_reference>()->get_name() == "self") {
+ return true;
+ }
+ // `return self.someMethod()`
+ if (auto v_call = return_expr->try_as<ast_function_call>(); v_call && v_call->is_dot_call()) {
+ return v_call->fun_maybe && v_call->fun_maybe->does_return_self() && is_expr_valid_as_return_self(v_call->get_dot_obj());
+ }
+ // `return cond ? ... : ...`
+ if (auto v_ternary = return_expr->try_as<ast_ternary_operator>()) {
+ return is_expr_valid_as_return_self(v_ternary->get_when_true()) && is_expr_valid_as_return_self(v_ternary->get_when_false());
+ }
+ return false;
+ }
+
+ void process_return_statement(V<ast_return_statement> v) {
+ if (v->has_return_value()) {
+ infer_any_expr(v->get_return_value(), current_function->declared_return_type);
+ } else {
+ assign_inferred_type(v->get_return_value(), TypeDataVoid::create());
+ }
+ if (current_function->does_return_self()) {
+ return_unifier.unify_with(current_function->parameters[0].declared_type);
+ if (!is_expr_valid_as_return_self(v->get_return_value())) {
+ v->error("invalid return from `self` function");
+ }
+ return;
+ }
+
+ TypePtr expr_type = v->get_return_value()->inferred_type;
+ if (current_function->declared_return_type) {
+ if (!current_function->declared_return_type->can_rhs_be_assigned(expr_type)) {
+ v->get_return_value()->error("can not convert type " + to_string(expr_type) + " to return type " + to_string(current_function->declared_return_type));
+ }
+ } else {
+ if (!return_unifier.unify_with(expr_type)) {
+ v->get_return_value()->error("can not unify type " + to_string(expr_type) + " with previous return type " + to_string(return_unifier.get_result()));
+ }
+ }
+ }
+
+ void process_if_statement(V<ast_if_statement> v) {
+ AnyExprV cond = v->get_cond();
+ infer_any_expr(cond);
+ if (!expect_integer(cond) && !expect_boolean(cond)) {
+ cond->error("can not use " + to_string(cond) + " as a boolean condition");
+ }
+ process_any_statement(v->get_if_body());
+ process_any_statement(v->get_else_body());
+ }
+
+ void process_repeat_statement(V<ast_repeat_statement> v) {
+ AnyExprV cond = v->get_cond();
+ infer_any_expr(cond);
+ if (!expect_integer(cond)) {
+ cond->error("condition of `repeat` must be an integer, got " + to_string(cond));
+ }
+ process_any_statement(v->get_body());
+ }
+
+ void process_while_statement(V<ast_while_statement> v) {
+ AnyExprV cond = v->get_cond();
+ infer_any_expr(cond);
+ if (!expect_integer(cond) && !expect_boolean(cond)) {
+ cond->error("can not use " + to_string(cond) + " as a boolean condition");
+ }
+ process_any_statement(v->get_body());
+ }
+
+ void process_do_while_statement(V<ast_do_while_statement> v) {
+ process_any_statement(v->get_body());
+ AnyExprV cond = v->get_cond();
+ infer_any_expr(cond);
+ if (!expect_integer(cond) && !expect_boolean(cond)) {
+ cond->error("can not use " + to_string(cond) + " as a boolean condition");
+ }
+ }
+
+ void process_throw_statement(V<ast_throw_statement> v) {
+ infer_any_expr(v->get_thrown_code());
+ if (!expect_integer(v->get_thrown_code())) {
+ v->get_thrown_code()->error("excNo of `throw` must be an integer, got " + to_string(v->get_thrown_code()));
+ }
+ infer_any_expr(v->get_thrown_arg());
+ if (v->has_thrown_arg() && v->get_thrown_arg()->inferred_type->calc_width_on_stack() != 1) {
+ v->get_thrown_arg()->error("can not throw " + to_string(v->get_thrown_arg()) + ", exception arg must occupy exactly 1 stack slot");
+ }
+ }
+
+ void process_assert_statement(V<ast_assert_statement> v) {
+ AnyExprV cond = v->get_cond();
+ infer_any_expr(cond);
+ if (!expect_integer(cond) && !expect_boolean(cond)) {
+ cond->error("can not use " + to_string(cond) + " as a boolean condition");
+ }
+ infer_any_expr(v->get_thrown_code());
+ if (!expect_integer(v->get_thrown_code())) {
+ v->get_cond()->error("thrown excNo of `assert` must be an integer, got " + to_string(v->get_cond()));
+ }
+ }
+
+ static void process_catch_variable(AnyExprV catch_var, TypePtr catch_var_type) {
+ if (auto v_ref = catch_var->try_as<ast_reference>(); v_ref && v_ref->sym) { // not underscore
+ assign_inferred_type(v_ref->sym->as<LocalVarData>(), catch_var_type);
+ }
+ assign_inferred_type(catch_var, catch_var_type);
+ }
+
+ void process_try_catch_statement(V<ast_try_catch_statement> v) {
+ process_any_statement(v->get_try_body());
+
+ // `catch` has exactly 2 variables: excNo and arg (when missing, they are implicit underscores)
+ // `arg` is a curious thing, it can be any TVM primitive, so assign unknown to it
+ // hence, using `fInt(arg)` (int from parameter is a hint) or `arg as slice` works well
+ // it's not truly correct, because `arg as (int,int)` also compiles, but can never happen, but let it be user responsibility
+ tolk_assert(v->get_catch_expr()->size() == 2);
+ std::vector<TypePtr> types_list = {TypeDataInt::create(), TypeDataUnknown::create()};
+ process_catch_variable(v->get_catch_expr()->get_item(0), types_list[0]);
+ process_catch_variable(v->get_catch_expr()->get_item(1), types_list[1]);
+ assign_inferred_type(v->get_catch_expr(), TypeDataTensor::create(std::move(types_list)));
+
+ process_any_statement(v->get_catch_body());
+ }
+
+public:
+ static void assign_fun_full_type(const FunctionData* fun_ref, TypePtr inferred_return_type) {
+ // calculate function full type `fun(params) -> ret_type`
+ std::vector<TypePtr> params_types;
+ params_types.reserve(fun_ref->get_num_params());
+ for (const LocalVarData& param : fun_ref->parameters) {
+ params_types.push_back(param.declared_type);
+ }
+ assign_inferred_type(fun_ref, inferred_return_type, TypeDataFunCallable::create(std::move(params_types), inferred_return_type));
+ }
+
+ void start_visiting_function(const FunctionData* fun_ref, V<ast_function_declaration> v_function) {
+ if (fun_ref->is_code_function()) {
+ current_function = fun_ref;
+ process_any_statement(v_function->get_body());
+ current_function = nullptr;
+
+ if (fun_ref->is_implicit_return()) {
+ bool is_ok_with_void = fun_ref->declared_return_type
+ ? fun_ref->declared_return_type->can_rhs_be_assigned(TypeDataVoid::create())
+ : return_unifier.unify_with_implicit_return_void();
+ if (!is_ok_with_void || fun_ref->does_return_self()) {
+ throw ParseError(v_function->get_body()->as<ast_sequence>()->loc_end, "missing return");
+ }
+ }
+ } else {
+ // asm functions should be strictly typed, this was checked earlier
+ tolk_assert(fun_ref->declared_return_type);
+ }
+
+ TypePtr inferred_return_type = fun_ref->declared_return_type ? fun_ref->declared_return_type : return_unifier.get_result();
+ assign_fun_full_type(fun_ref, inferred_return_type);
+ fun_ref->mutate()->assign_is_type_inferring_done();
+ }
+};
+
+class LaunchInferTypesAndMethodsOnce final {
+public:
+ static bool should_visit_function(const FunctionData* fun_ref) {
+ // since inferring can be requested on demand, prevent second execution from a regular pipeline launcher
+ return !fun_ref->is_type_inferring_done() && !fun_ref->is_generic_function();
+ }
+
+ static void start_visiting_function(const FunctionData* fun_ref, V<ast_function_declaration> v_function) {
+ InferCheckTypesAndCallsAndFieldsVisitor visitor;
+ visitor.start_visiting_function(fun_ref, v_function);
+ }
+};
+
+// infer return type "on demand"
+// example: `fun f() { return g(); } fun g() { ... }`
+// when analyzing `f()`, we need to infer what fun_ref=g returns
+// (if `g` is generic, it was already instantiated, so fun_ref=g<int> is here)
+static void infer_and_save_return_type_of_function(const FunctionData* fun_ref) {
+ static std::vector<const FunctionData*> called_stack;
+
+ tolk_assert(!fun_ref->is_generic_function() && !fun_ref->is_type_inferring_done());
+ // if `g` has return type declared, like `fun g(): int { ... }`, don't traverse its body
+ if (fun_ref->declared_return_type) {
+ InferCheckTypesAndCallsAndFieldsVisitor::assign_fun_full_type(fun_ref, fun_ref->declared_return_type);
+ return;
+ }
+
+ // prevent recursion of untyped functions, like `fun f() { return g(); } fun g() { return f(); }`
+ bool contains = std::find(called_stack.begin(), called_stack.end(), fun_ref) != called_stack.end();
+ if (contains) {
+ fun_ref->ast_root->error("could not infer return type of " + to_string(fun_ref) + ", because it appears in a recursive call chain; specify `: <return_type>` manually");
+ }
+
+ // dig into g's body; it's safe, since the compiler is single-threaded
+ // on finish, fun_ref->inferred_return_type is filled, and won't be called anymore
+ called_stack.push_back(fun_ref);
+ InferCheckTypesAndCallsAndFieldsVisitor visitor;
+ visitor.start_visiting_function(fun_ref, fun_ref->ast_root->as<ast_function_declaration>());
+ called_stack.pop_back();
+}
+
+void pipeline_infer_types_and_calls_and_fields() {
+ visit_ast_of_all_functions<LaunchInferTypesAndMethodsOnce>();
+}
+
+void pipeline_infer_types_and_calls_and_fields(const FunctionData* fun_ref) {
+ InferCheckTypesAndCallsAndFieldsVisitor visitor;
+ visitor.start_visiting_function(fun_ref, fun_ref->ast_root->as<ast_function_declaration>());
+}
+
+} // namespace tolk
diff --git a/tolk/pipe-optimize-boolean-expr.cpp b/tolk/pipe-optimize-boolean-expr.cpp
new file mode 100644
index 000000000..037502566
--- /dev/null
+++ b/tolk/pipe-optimize-boolean-expr.cpp
@@ -0,0 +1,172 @@
+/*
+ This file is part of TON Blockchain source code.
+
+ TON Blockchain is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ TON Blockchain is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with TON Blockchain. If not, see <http://www.gnu.org/licenses/>.
+*/
+#include "tolk.h"
+#include "ast.h"
+#include "ast-replacer.h"
+#include "type-system.h"
+
+/*
+ * This pipe does some optimizations related to booleans.
+ * It happens after type inferring, when we know types of all expressions.
+ *
+ * Example: `boolVar == true` -> `boolVar`.
+ * Example: `!!boolVar` -> `boolVar`.
+ * Also in unwraps parenthesis inside if condition and similar: `assert(((x)), 404)` -> `assert(x, 404)`
+ *
+ * todo some day, replace && || with & | when it's safe (currently, && always produces IFs in Fift)
+ * It's tricky to implement whether replacing is safe.
+ * For example, safe: `a > 0 && a < 10` / `a != 3 && a != 5`
+ * For example, unsafe: `cached && calc()` / `a > 0 && log(a)` / `b != 0 && a / b > 1` / `i >= 0 && arr[idx]` / `f != null && close(f)`
+ */
+
+namespace tolk {
+
+static AnyExprV unwrap_parenthesis(AnyExprV v) {
+ while (v->type == ast_parenthesized_expression) {
+ v = v->as<ast_parenthesized_expression>()->get_expr();
+ }
+ return v;
+}
+
+struct OptimizerBooleanExpressionsReplacer final : ASTReplacerInFunctionBody {
+ static V<ast_int_const> create_int_const(SrcLocation loc, td::RefInt256&& intval) {
+ auto v_int = createV<ast_int_const>(loc, std::move(intval), {});
+ v_int->assign_inferred_type(TypeDataInt::create());
+ v_int->assign_rvalue_true();
+ return v_int;
+ }
+
+ static V<ast_bool_const> create_bool_const(SrcLocation loc, bool bool_val) {
+ auto v_bool = createV<ast_bool_const>(loc, bool_val);
+ v_bool->assign_inferred_type(TypeDataInt::create());
+ v_bool->assign_rvalue_true();
+ return v_bool;
+ }
+
+ static V<ast_unary_operator> create_logical_not_for_bool(SrcLocation loc, AnyExprV rhs) {
+ auto v_not = createV<ast_unary_operator>(loc, "!", tok_logical_not, rhs);
+ v_not->assign_inferred_type(TypeDataBool::create());
+ v_not->assign_rvalue_true();
+ v_not->assign_fun_ref(lookup_global_symbol("!b_")->as<FunctionData>());
+ return v_not;
+ }
+
+protected:
+
+ AnyExprV replace(V<ast_unary_operator> v) override {
+ parent::replace(v);
+
+ if (v->tok == tok_logical_not) {
+ if (auto inner_not = v->get_rhs()->try_as<ast_unary_operator>(); inner_not && inner_not->tok == tok_logical_not) {
+ AnyExprV cond_not_not = inner_not->get_rhs();
+ // `!!boolVar` => `boolVar`
+ if (cond_not_not->inferred_type == TypeDataBool::create()) {
+ return cond_not_not;
+ }
+ // `!!intVar` => `intVar != 0`
+ if (cond_not_not->inferred_type == TypeDataInt::create()) {
+ auto v_zero = create_int_const(v->loc, td::make_refint(0));
+ auto v_neq = createV<ast_binary_operator>(v->loc, "!=", tok_neq, cond_not_not, v_zero);
+ v_neq->mutate()->assign_rvalue_true();
+ v_neq->mutate()->assign_inferred_type(TypeDataBool::create());
+ v_neq->mutate()->assign_fun_ref(lookup_global_symbol("_!=_")->as<FunctionData>());
+ return v_neq;
+ }
+ }
+ if (auto inner_bool = v->get_rhs()->try_as<ast_bool_const>()) {
+ // `!true` / `!false`
+ return create_bool_const(v->loc, !inner_bool->bool_val);
+ }
+ }
+
+ return v;
+ }
+
+ AnyExprV replace(V<ast_binary_operator> v) override {
+ parent::replace(v);
+
+ if (v->tok == tok_eq || v->tok == tok_neq) {
+ AnyExprV lhs = v->get_lhs();
+ AnyExprV rhs = v->get_rhs();
+ if (lhs->inferred_type == TypeDataBool::create() && rhs->type == ast_bool_const) {
+ // `boolVar == true` / `boolVar != false`
+ if (rhs->as<ast_bool_const>()->bool_val ^ (v->tok == tok_neq)) {
+ return lhs;
+ }
+ // `boolVar != true` / `boolVar == false`
+ return create_logical_not_for_bool(v->loc, lhs);
+ }
+ }
+
+ return v;
+ }
+
+ AnyV replace(V<ast_if_statement> v) override {
+ parent::replace(v);
+ if (v->get_cond()->type == ast_parenthesized_expression) {
+ v = createV<ast_if_statement>(v->loc, v->is_ifnot, unwrap_parenthesis(v->get_cond()), v->get_if_body(), v->get_else_body());
+ }
+
+ // `if (!x)` -> ifnot(x)
+ while (auto v_cond_unary = v->get_cond()->try_as<ast_unary_operator>()) {
+ if (v_cond_unary->tok != tok_logical_not) {
+ break;
+ }
+ v = createV<ast_if_statement>(v->loc, !v->is_ifnot, v_cond_unary->get_rhs(), v->get_if_body(), v->get_else_body());
+ }
+
+ return v;
+ }
+
+ AnyV replace(V<ast_while_statement> v) override {
+ parent::replace(v);
+
+ if (v->get_cond()->type == ast_parenthesized_expression) {
+ v = createV<ast_while_statement>(v->loc, unwrap_parenthesis(v->get_cond()), v->get_body());
+ }
+ return v;
+ }
+
+ AnyV replace(V<ast_do_while_statement> v) override {
+ parent::replace(v);
+
+ if (v->get_cond()->type == ast_parenthesized_expression) {
+ v = createV<ast_do_while_statement>(v->loc, v->get_body(), unwrap_parenthesis(v->get_cond()));
+ }
+ return v;
+ }
+
+ AnyV replace(V<ast_assert_statement> v) override {
+ parent::replace(v);
+
+ if (v->get_cond()->type == ast_parenthesized_expression) {
+ v = createV<ast_assert_statement>(v->loc, unwrap_parenthesis(v->get_cond()), v->get_thrown_code());
+ }
+ return v;
+ }
+
+public:
+ bool should_visit_function(const FunctionData* fun_ref) override {
+ return fun_ref->is_code_function() && !fun_ref->is_generic_function();
+ }
+};
+
+void pipeline_optimize_boolean_expressions() {
+ replace_ast_of_all_functions<OptimizerBooleanExpressionsReplacer>();
+}
+
+} // namespace tolk
diff --git a/tolk/pipe-refine-lvalue-for-mutate.cpp b/tolk/pipe-refine-lvalue-for-mutate.cpp
new file mode 100644
index 000000000..45dd3a94f
--- /dev/null
+++ b/tolk/pipe-refine-lvalue-for-mutate.cpp
@@ -0,0 +1,126 @@
+/*
+ This file is part of TON Blockchain source code.
+
+ TON Blockchain is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ TON Blockchain is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with TON Blockchain. If not, see <http://www.gnu.org/licenses/>.
+*/
+#include "tolk.h"
+#include "ast.h"
+#include "ast-visitor.h"
+
+/*
+ * This pipe refines rvalue/lvalue and checks `mutate` arguments validity.
+ * It happens after type inferring (after methods binding), because it uses fun_ref of calls.
+ *
+ * Example: `a.increment().increment()`, the first `a.increment()` becomes lvalue (assume that increment mutates self).
+ * Example: `increment(a)` is invalid, should be `increment(mutate a)`.
+ *
+ * Note, that explicitly specifying `mutate` for arguments, like `increment(mutate a)` is on purpose.
+ * If we wished `increment(a)` to be valid (to work and mutate `a`, like passing by ref), it would also be done here,
+ * refining `a` to be lvalue. But to avoid unexpected mutations, `mutate` keyword for an argument is required.
+ * So, for mutated arguments, instead of setting lvalue, we check its presence.
+ */
+
+namespace tolk {
+
+GNU_ATTRIBUTE_NORETURN GNU_ATTRIBUTE_COLD
+static void fire_error_invalid_mutate_arg_passed(AnyExprV v, const FunctionData* fun_ref, const LocalVarData& p_sym, bool called_as_method, bool arg_passed_as_mutate, AnyV arg_expr) {
+ std::string arg_str(arg_expr->type == ast_reference ? arg_expr->as<ast_reference>()->get_name() : "obj");
+
+ // case: `loadInt(cs, 32)`; suggest: `cs.loadInt(32)`
+ if (p_sym.is_mutate_parameter() && !arg_passed_as_mutate && !called_as_method && p_sym.idx == 0 && fun_ref->does_accept_self()) {
+ v->error("`" + fun_ref->name + "` is a mutating method; consider calling `" + arg_str + "." + fun_ref->name + "()`, not `" + fun_ref->name + "(" + arg_str + ")`");
+ }
+ // case: `cs.mutating_function()`; suggest: `mutating_function(mutate cs)` or make it a method
+ if (p_sym.is_mutate_parameter() && called_as_method && p_sym.idx == 0 && !fun_ref->does_accept_self()) {
+ v->error("function `" + fun_ref->name + "` mutates parameter `" + p_sym.name + "`; consider calling `" + fun_ref->name + "(mutate " + arg_str + ")`, not `" + arg_str + "." + fun_ref->name + "`(); alternatively, rename parameter to `self` to make it a method");
+ }
+ // case: `mutating_function(arg)`; suggest: `mutate arg`
+ if (p_sym.is_mutate_parameter() && !arg_passed_as_mutate) {
+ v->error("function `" + fun_ref->name + "` mutates parameter `" + p_sym.name + "`; you need to specify `mutate` when passing an argument, like `mutate " + arg_str + "`");
+ }
+ // case: `usual_function(mutate arg)`
+ if (!p_sym.is_mutate_parameter() && arg_passed_as_mutate) {
+ v->error("incorrect `mutate`, since `" + fun_ref->name + "` does not mutate this parameter");
+ }
+ throw Fatal("unreachable");
+}
+
+
+class RefineLvalueForMutateArgumentsVisitor final : public ASTVisitorFunctionBody {
+ void visit(V<ast_function_call> v) override {
+ // v is `globalF(args)` / `globalF<int>(args)` / `obj.method(args)` / `local_var(args)` / `getF()(args)`
+ const FunctionData* fun_ref = v->fun_maybe;
+ if (!fun_ref) {
+ parent::visit(v);
+ for (int i = 0; i < v->get_num_args(); ++i) {
+ auto v_arg = v->get_arg(i);
+ if (v_arg->passed_as_mutate) {
+ v_arg->error("`mutate` used for non-mutate argument");
+ }
+ }
+ return;
+ }
+
+ int delta_self = v->is_dot_call();
+ tolk_assert(fun_ref->get_num_params() == delta_self + v->get_num_args());
+
+ if (v->is_dot_call()) {
+ if (fun_ref->does_mutate_self()) {
+ // for `b.storeInt()`, `b` should become lvalue, since `storeInt` is a method mutating self
+ // but: `beginCell().storeInt()`, then `beginCell()` is not lvalue
+ // (it will be extracted as tmp var when transforming AST to IR)
+ AnyExprV leftmost_obj = v->get_dot_obj();
+ while (true) {
+ if (auto as_par = leftmost_obj->try_as<ast_parenthesized_expression>()) {
+ leftmost_obj = as_par->get_expr();
+ } else if (auto as_cast = leftmost_obj->try_as<ast_cast_as_operator>()) {
+ leftmost_obj = as_cast->get_expr();
+ } else {
+ break;
+ }
+ }
+ bool will_be_extracted_as_tmp_var = leftmost_obj->type == ast_function_call;
+ if (!will_be_extracted_as_tmp_var) {
+ leftmost_obj->mutate()->assign_lvalue_true();
+ v->get_dot_obj()->mutate()->assign_lvalue_true();
+ }
+ }
+
+ if (!fun_ref->does_accept_self() && fun_ref->parameters[0].is_mutate_parameter()) {
+ fire_error_invalid_mutate_arg_passed(v, fun_ref, fun_ref->parameters[0], true, false, v->get_dot_obj());
+ }
+ }
+
+ for (int i = 0; i < v->get_num_args(); ++i) {
+ const LocalVarData& p_sym = fun_ref->parameters[delta_self + i];
+ auto arg_i = v->get_arg(i);
+ if (p_sym.is_mutate_parameter() != arg_i->passed_as_mutate) {
+ fire_error_invalid_mutate_arg_passed(arg_i, fun_ref, p_sym, false, arg_i->passed_as_mutate, arg_i->get_expr());
+ }
+ parent::visit(arg_i);
+ }
+ parent::visit(v->get_callee());
+ }
+
+public:
+ bool should_visit_function(const FunctionData* fun_ref) override {
+ return fun_ref->is_code_function() && !fun_ref->is_generic_function();
+ }
+};
+
+void pipeline_refine_lvalue_for_mutate_arguments() {
+ visit_ast_of_all_functions<RefineLvalueForMutateArgumentsVisitor>();
+}
+
+} // namespace tolk
diff --git a/tolk/pipe-register-symbols.cpp b/tolk/pipe-register-symbols.cpp
index 569d434aa..2dae0d233 100644
--- a/tolk/pipe-register-symbols.cpp
+++ b/tolk/pipe-register-symbols.cpp
@@ -13,340 +13,214 @@
You should have received a copy of the GNU General Public License
along with TON Blockchain. If not, see <http://www.gnu.org/licenses/>.
-
- In addition, as a special exception, the copyright holders give permission
- to link the code of portions of this program with the OpenSSL library.
- You must obey the GNU General Public License in all respects for all
- of the code used other than OpenSSL. If you modify file(s) with this
- exception, you may extend this exception to your version of the file(s),
- but you are not obligated to do so. If you do not wish to do so, delete this
- exception statement from your version. If you delete this exception statement
- from all source files in the program, then also delete it here.
*/
#include "tolk.h"
#include "platform-utils.h"
#include "src-file.h"
#include "ast.h"
#include "compiler-state.h"
+#include "constant-evaluator.h"
+#include "generics-helpers.h"
#include "td/utils/crypto.h"
+#include "type-system.h"
#include <unordered_set>
-namespace tolk {
-
-Expr* process_expr(AnyV v, CodeBlob& code);
-
-GNU_ATTRIBUTE_NORETURN GNU_ATTRIBUTE_COLD
-static void fire_error_redefinition_of_symbol(V<ast_identifier> v_ident, SymDef* existing) {
- if (existing->loc.is_stdlib()) {
- v_ident->error("redefinition of a symbol from stdlib");
- } else if (existing->loc.is_defined()) {
- v_ident->error("redefinition of symbol, previous was at: " + existing->loc.to_string());
- } else {
- v_ident->error("redefinition of built-in symbol");
- }
-}
+/*
+ * This pipe registers global symbols: functions, constants, global vars, etc.
+ * It happens just after all files have been parsed to AST.
+ *
+ * "Registering" means adding symbols to a global symbol table.
+ * After this pass, any global symbol can be looked up.
+ * Note, that local variables are not analyzed here, it's a later step.
+ * Before digging into locals, we need a global symtable to be filled, exactly done here.
+ */
-static int calc_sym_idx(std::string_view sym_name) {
- return G.symbols.lookup_add(sym_name);
-}
+namespace tolk {
-static td::RefInt256 calculate_method_id_for_entrypoint(std::string_view func_name) {
+static int calculate_method_id_for_entrypoint(std::string_view func_name) {
if (func_name == "main" || func_name == "onInternalMessage") {
- return td::make_refint(0);
+ return 0;
}
if (func_name == "onExternalMessage") {
- return td::make_refint(-1);
+ return -1;
}
if (func_name == "onRunTickTock") {
- return td::make_refint(-2);
+ return -2;
}
if (func_name == "onSplitPrepare") {
- return td::make_refint(-3);
+ return -3;
}
if (func_name == "onSplitInstall") {
- return td::make_refint(-4);
+ return -4;
}
tolk_assert(false);
}
-static td::RefInt256 calculate_method_id_by_func_name(std::string_view func_name) {
+static int calculate_method_id_by_func_name(std::string_view func_name) {
unsigned int crc = td::crc16(static_cast<std::string>(func_name));
- return td::make_refint((crc & 0xffff) | 0x10000);
+ return static_cast<int>(crc & 0xffff) | 0x10000;
}
-static void calc_arg_ret_order_of_asm_function(V<ast_asm_body> v_body, V<ast_parameter_list> param_list, TypeExpr* ret_type,
- std::vector<int>& arg_order, std::vector<int>& ret_order) {
- int cnt = param_list->size();
- int width = ret_type->get_width();
- if (width < 0 || width > 16) {
- v_body->error("return type of an assembler built-in function must have a well-defined fixed width");
+static void validate_arg_ret_order_of_asm_function(V<ast_asm_body> v_body, int n_params, TypePtr ret_type) {
+ if (!ret_type) {
+ v_body->error("asm function must declare return type (before asm instructions)");
}
- if (cnt > 16) {
- v_body->error("assembler built-in function must have at most 16 arguments");
- }
- std::vector<int> cum_arg_width;
- cum_arg_width.push_back(0);
- int tot_width = 0;
- for (int i = 0; i < cnt; ++i) {
- V<ast_parameter> v_param = param_list->get_param(i);
- int arg_width = v_param->param_type->get_width();
- if (arg_width < 0 || arg_width > 16) {
- v_param->error("parameters of an assembler built-in function must have a well-defined fixed width");
- }
- cum_arg_width.push_back(tot_width += arg_width);
+ if (n_params > 16) {
+ v_body->error("asm function can have at most 16 parameters");
}
+
+ // asm(param1 ... paramN), param names were previously mapped into indices
if (!v_body->arg_order.empty()) {
- if (static_cast<int>(v_body->arg_order.size()) != cnt) {
+ if (static_cast<int>(v_body->arg_order.size()) != n_params) {
v_body->error("arg_order of asm function must specify all parameters");
}
- std::vector<bool> visited(cnt, false);
- for (int i = 0; i < cnt; ++i) {
- int j = v_body->arg_order[i];
+ std::vector<bool> visited(v_body->arg_order.size(), false);
+ for (int j : v_body->arg_order) {
if (visited[j]) {
v_body->error("arg_order of asm function contains duplicates");
}
visited[j] = true;
- int c1 = cum_arg_width[j], c2 = cum_arg_width[j + 1];
- while (c1 < c2) {
- arg_order.push_back(c1++);
- }
}
- tolk_assert(arg_order.size() == (unsigned)tot_width);
}
+
+ // asm(-> 0 2 1 3), check for a shuffled range 0...N
+ // correctness of N (actual return width onto a stack) will be checked after type inferring and generics instantiation
if (!v_body->ret_order.empty()) {
- if (static_cast<int>(v_body->ret_order.size()) != width) {
- v_body->error("ret_order of this asm function expected to be width = " + std::to_string(width));
- }
- std::vector<bool> visited(width, false);
- for (int i = 0; i < width; ++i) {
- int j = v_body->ret_order[i];
- if (j < 0 || j >= width || visited[j]) {
- v_body->error("ret_order contains invalid integer, not in range 0 .. width-1");
+ std::vector<bool> visited(v_body->ret_order.size(), false);
+ for (int j : v_body->ret_order) {
+ if (j < 0 || j >= static_cast<int>(v_body->ret_order.size()) || visited[j]) {
+ v_body->error("ret_order contains invalid integer, not in range 0 .. N");
}
visited[j] = true;
}
- ret_order = v_body->ret_order;
}
}
-static void register_constant(V<ast_constant_declaration> v) {
- AnyV init_value = v->get_init_value();
- SymDef* sym_def = define_global_symbol(calc_sym_idx(v->get_identifier()->name), v->loc);
- if (sym_def->value) {
- fire_error_redefinition_of_symbol(v->get_identifier(), sym_def);
- }
+static const GenericsDeclaration* construct_genericTs(V<ast_genericsT_list> v_list) {
+ std::vector<GenericsDeclaration::GenericsItem> itemsT;
+ itemsT.reserve(v_list->size());
- // todo currently, constant value calculation is dirty and roughly: init_value is evaluated to fif code
- // and waited to be a single expression
- // although it works, of course it should be later rewritten using AST calculations, as well as lots of other parts
- CodeBlob code("tmp", v->loc, nullptr, nullptr);
- Expr* x = process_expr(init_value, code);
- if (!x->is_rvalue()) {
- v->get_init_value()->error("expression is not strictly Rvalue");
- }
- if (v->declared_type && !v->declared_type->equals_to(x->e_type)) {
- v->error("expression type does not match declared type");
- }
- SymValConst* sym_val = nullptr;
- if (x->cls == Expr::_Const) { // Integer constant
- sym_val = new SymValConst(static_cast<int>(G.all_constants.size()), x->intval);
- } else if (x->cls == Expr::_SliceConst) { // Slice constant (string)
- sym_val = new SymValConst(static_cast<int>(G.all_constants.size()), x->strval);
- } else if (x->cls == Expr::_Apply) { // even "1 + 2" is Expr::_Apply (it applies `_+_`)
- code.emplace_back(v->loc, Op::_Import, std::vector<var_idx_t>());
- auto tmp_vars = x->pre_compile(code);
- code.emplace_back(v->loc, Op::_Return, std::move(tmp_vars));
- code.emplace_back(v->loc, Op::_Nop);
- // It is REQUIRED to execute "optimizations" as in tolk.cpp
- code.simplify_var_types();
- code.prune_unreachable_code();
- code.split_vars(true);
- for (int i = 0; i < 16; i++) {
- code.compute_used_code_vars();
- code.fwd_analyze();
- code.prune_unreachable_code();
- }
- code.mark_noreturn();
- AsmOpList out_list(0, &code.vars);
- code.generate_code(out_list);
- if (out_list.list_.size() != 1) {
- init_value->error("precompiled expression must result in single operation");
+ for (int i = 0; i < v_list->size(); ++i) {
+ auto v_item = v_list->get_item(i);
+ auto it_existing = std::find_if(itemsT.begin(), itemsT.end(), [v_item](const GenericsDeclaration::GenericsItem& prev) {
+ return prev.nameT == v_item->nameT;
+ });
+ if (it_existing != itemsT.end()) {
+ v_item->error("duplicate generic parameter `" + static_cast<std::string>(v_item->nameT) + "`");
}
- auto op = out_list.list_[0];
- if (!op.is_const()) {
- init_value->error("precompiled expression must result in compilation time constant");
- }
- if (op.origin.is_null() || !op.origin->is_valid()) {
- init_value->error("precompiled expression did not result in a valid integer constant");
+ itemsT.emplace_back(v_item->nameT);
+ }
+
+ return new GenericsDeclaration(std::move(itemsT));
+}
+
+static void register_constant(V<ast_constant_declaration> v) {
+ ConstantValue init_value = eval_const_init_value(v->get_init_value());
+ GlobalConstData* c_sym = new GlobalConstData(static_cast<std::string>(v->get_identifier()->name), v->loc, v->declared_type, std::move(init_value));
+
+ if (v->declared_type) {
+ bool ok = (c_sym->is_int_const() && (v->declared_type == TypeDataInt::create()))
+ || (c_sym->is_slice_const() && (v->declared_type == TypeDataSlice::create()));
+ if (!ok) {
+ v->error("expression type does not match declared type");
}
- sym_val = new SymValConst(static_cast<int>(G.all_constants.size()), op.origin);
- } else {
- init_value->error("integer or slice literal or constant expected");
}
- sym_def->value = sym_val;
-#ifdef TOLK_DEBUG
- sym_def->value->sym_name = v->get_identifier()->name;
-#endif
- G.all_constants.push_back(sym_def);
+ G.symtable.add_global_const(c_sym);
+ G.all_constants.push_back(c_sym);
+ v->mutate()->assign_const_ref(c_sym);
}
static void register_global_var(V<ast_global_var_declaration> v) {
- SymDef* sym_def = define_global_symbol(calc_sym_idx(v->get_identifier()->name), v->loc);
- if (sym_def->value) {
- fire_error_redefinition_of_symbol(v->get_identifier(), sym_def);
- }
+ GlobalVarData* g_sym = new GlobalVarData(static_cast<std::string>(v->get_identifier()->name), v->loc, v->declared_type);
- sym_def->value = new SymValGlobVar(static_cast<int>(G.all_global_vars.size()), v->declared_type);
-#ifdef TOLK_DEBUG
- sym_def->value->sym_name = v->get_identifier()->name;
-#endif
- G.all_global_vars.push_back(sym_def);
+ G.symtable.add_global_var(g_sym);
+ G.all_global_vars.push_back(g_sym);
+ v->mutate()->assign_var_ref(g_sym);
}
-static SymDef* register_parameter(V<ast_parameter> v, int idx) {
+static LocalVarData register_parameter(V<ast_parameter> v, int idx) {
if (v->is_underscore()) {
- return nullptr;
- }
- SymDef* sym_def = define_parameter(calc_sym_idx(v->get_identifier()->name), v->loc);
- if (sym_def->value) {
- // todo always false now, how to detect similar parameter names? (remember about underscore)
- v->error("redefined parameter");
+ return {"", v->loc, v->declared_type, 0, idx};
}
- SymValVariable* sym_val = new SymValVariable(idx, v->param_type);
+ int flags = 0;
if (v->declared_as_mutate) {
- sym_val->flags |= SymValVariable::flagMutateParameter;
+ flags |= LocalVarData::flagMutateParameter;
}
- if (!v->declared_as_mutate && idx == 0 && v->get_identifier()->name == "self") {
- sym_val->flags |= SymValVariable::flagImmutable;
+ if (!v->declared_as_mutate && idx == 0 && v->param_name == "self") {
+ flags |= LocalVarData::flagImmutable;
}
- sym_def->value = sym_val;
-#ifdef TOLK_DEBUG
- sym_def->value->sym_name = v->get_identifier()->name;
-#endif
- return sym_def;
+ return LocalVarData(static_cast<std::string>(v->param_name), v->loc, v->declared_type, flags, idx);
}
static void register_function(V<ast_function_declaration> v) {
std::string_view func_name = v->get_identifier()->name;
- // calculate TypeExpr of a function: it's a map (params -> ret), probably surrounded by forall
- TypeExpr* params_tensor_type = nullptr;
+ // calculate TypeData of a function
+ std::vector<TypePtr> arg_types;
+ std::vector<LocalVarData> parameters;
int n_params = v->get_num_params();
int n_mutate_params = 0;
- std::vector<SymDef*> parameters_syms;
- if (n_params) {
- std::vector<TypeExpr*> param_tensor_items;
- param_tensor_items.reserve(n_params);
- parameters_syms.reserve(n_params);
- for (int i = 0; i < n_params; ++i) {
- auto v_param = v->get_param(i);
- n_mutate_params += static_cast<int>(v_param->declared_as_mutate);
- param_tensor_items.emplace_back(v_param->param_type);
- parameters_syms.emplace_back(register_parameter(v_param, i));
- }
- params_tensor_type = TypeExpr::new_tensor(std::move(param_tensor_items));
- } else {
- params_tensor_type = TypeExpr::new_unit();
+ arg_types.reserve(n_params);
+ parameters.reserve(n_params);
+ for (int i = 0; i < n_params; ++i) {
+ auto v_param = v->get_param(i);
+ arg_types.emplace_back(v_param->declared_type);
+ parameters.emplace_back(register_parameter(v_param, i));
+ n_mutate_params += static_cast<int>(v_param->declared_as_mutate);
}
- TypeExpr* function_type = TypeExpr::new_map(params_tensor_type, v->ret_type);
+ const GenericsDeclaration* genericTs = nullptr;
if (v->genericsT_list) {
- std::vector<TypeExpr*> type_vars;
- type_vars.reserve(v->genericsT_list->size());
- for (int idx = 0; idx < v->genericsT_list->size(); ++idx) {
- type_vars.emplace_back(v->genericsT_list->get_item(idx)->created_type);
- }
- function_type = TypeExpr::new_forall(std::move(type_vars), function_type);
+ genericTs = construct_genericTs(v->genericsT_list);
}
- if (v->marked_as_builtin) {
- const SymDef* builtin_func = lookup_symbol(G.symbols.lookup(func_name));
- const SymValFunc* func_val = builtin_func ? dynamic_cast<SymValFunc*>(builtin_func->value) : nullptr;
- if (!func_val || !func_val->is_builtin()) {
+ if (v->is_builtin_function()) {
+ const Symbol* builtin_func = lookup_global_symbol(func_name);
+ const FunctionData* fun_ref = builtin_func ? builtin_func->as<FunctionData>() : nullptr;
+ if (!fun_ref || !fun_ref->is_builtin_function()) {
v->error("`builtin` used for non-builtin function");
}
-#ifdef TOLK_DEBUG
- // in release, we don't need this check, since `builtin` is used only in stdlib, which is our responsibility
- if (!func_val->sym_type->equals_to(function_type) || func_val->is_marked_as_pure() != v->marked_as_pure) {
- v->error("declaration for `builtin` function doesn't match an actual one");
- }
-#endif
+ v->mutate()->assign_fun_ref(fun_ref);
return;
}
- SymDef* sym_def = define_global_symbol(calc_sym_idx(func_name), v->loc);
- if (sym_def->value) {
- fire_error_redefinition_of_symbol(v->get_identifier(), sym_def);
- }
- if (G.is_verbosity(1)) {
- std::cerr << "fun " << func_name << " : " << function_type << std::endl;
- }
- if (v->marked_as_pure && v->ret_type->get_width() == 0) {
- v->error("a pure function should return something, otherwise it will be optimized out anyway");
+ if (G.is_verbosity(1) && v->is_code_function()) {
+ std::cerr << "fun " << func_name << " : " << v->declared_return_type << std::endl;
}
- SymValFunc* sym_val = nullptr;
- if (const auto* v_seq = v->get_body()->try_as<ast_sequence>()) {
- sym_val = new SymValCodeFunc(std::move(parameters_syms), static_cast<int>(G.all_code_functions.size()), function_type);
- } else if (const auto* v_asm = v->get_body()->try_as<ast_asm_body>()) {
- std::vector<int> arg_order, ret_order;
- calc_arg_ret_order_of_asm_function(v_asm, v->get_param_list(), v->ret_type, arg_order, ret_order);
- sym_val = new SymValAsmFunc(std::move(parameters_syms), function_type, std::move(arg_order), std::move(ret_order), 0);
- } else {
- v->error("Unexpected function body statement");
+ FunctionBody f_body = v->get_body()->type == ast_sequence ? static_cast<FunctionBody>(new FunctionBodyCode) : static_cast<FunctionBody>(new FunctionBodyAsm);
+ FunctionData* f_sym = new FunctionData(static_cast<std::string>(func_name), v->loc, v->declared_return_type, std::move(parameters), 0, genericTs, nullptr, f_body, v);
+
+ if (const auto* v_asm = v->get_body()->try_as<ast_asm_body>()) {
+ validate_arg_ret_order_of_asm_function(v_asm, v->get_num_params(), v->declared_return_type);
+ f_sym->arg_order = v_asm->arg_order;
+ f_sym->ret_order = v_asm->ret_order;
}
- if (v->method_id) {
- sym_val->method_id = td::string_to_int256(static_cast<std::string>(v->method_id->int_val));
- if (sym_val->method_id.is_null()) {
- v->method_id->error("invalid integer constant");
- }
- } else if (v->marked_as_get_method) {
- sym_val->method_id = calculate_method_id_by_func_name(func_name);
- for (const SymDef* other : G.all_get_methods) {
- if (!td::cmp(dynamic_cast<const SymValFunc*>(other->value)->method_id, sym_val->method_id)) {
- v->error(PSTRING() << "GET methods hash collision: `" << other->name() << "` and `" << static_cast<std::string>(func_name) << "` produce the same hash. Consider renaming one of these functions.");
+ if (v->method_id.not_null()) {
+ f_sym->method_id = static_cast<int>(v->method_id->to_long());
+ } else if (v->flags & FunctionData::flagGetMethod) {
+ f_sym->method_id = calculate_method_id_by_func_name(func_name);
+ for (const FunctionData* other : G.all_get_methods) {
+ if (other->method_id == f_sym->method_id) {
+ v->error(PSTRING() << "GET methods hash collision: `" << other->name << "` and `" << f_sym->name << "` produce the same hash. Consider renaming one of these functions.");
}
}
- } else if (v->is_entrypoint) {
- sym_val->method_id = calculate_method_id_for_entrypoint(func_name);
- }
- if (v->marked_as_pure) {
- sym_val->flags |= SymValFunc::flagMarkedAsPure;
- }
- if (v->marked_as_inline) {
- sym_val->flags |= SymValFunc::flagInline;
- }
- if (v->marked_as_inline_ref) {
- sym_val->flags |= SymValFunc::flagInlineRef;
- }
- if (v->marked_as_get_method) {
- sym_val->flags |= SymValFunc::flagGetMethod;
- }
- if (v->is_entrypoint) {
- sym_val->flags |= SymValFunc::flagIsEntrypoint;
+ } else if (v->flags & FunctionData::flagIsEntrypoint) {
+ f_sym->method_id = calculate_method_id_for_entrypoint(func_name);
}
+ f_sym->flags |= v->flags;
if (n_mutate_params) {
- sym_val->flags |= SymValFunc::flagHasMutateParams;
- }
- if (v->accepts_self) {
- sym_val->flags |= SymValFunc::flagAcceptsSelf;
- }
- if (v->returns_self) {
- sym_val->flags |= SymValFunc::flagReturnsSelf;
+ f_sym->flags |= FunctionData::flagHasMutateParams;
}
- sym_def->value = sym_val;
-#ifdef TOLK_DEBUG
- sym_def->value->sym_name = func_name;
-#endif
- if (dynamic_cast<SymValCodeFunc*>(sym_val)) {
- G.all_code_functions.push_back(sym_def);
- }
- if (sym_val->is_get_method()) {
- G.all_get_methods.push_back(sym_def);
+ G.symtable.add_function(f_sym);
+ G.all_functions.push_back(f_sym);
+ if (f_sym->is_get_method()) {
+ G.all_get_methods.push_back(f_sym);
}
+ v->mutate()->assign_fun_ref(f_sym);
}
static void iterate_through_file_symbols(const SrcFile* file) {
@@ -358,10 +232,10 @@ static void iterate_through_file_symbols(const SrcFile* file) {
for (AnyV v : file->ast->as<ast_tolk_file>()->get_toplevel_declarations()) {
switch (v->type) {
- case ast_import_statement:
+ case ast_import_directive:
// on `import "another-file.tolk"`, register symbols from that file at first
// (for instance, it can calculate constants, which are used in init_val of constants in current file below import)
- iterate_through_file_symbols(v->as<ast_import_statement>()->file);
+ iterate_through_file_symbols(v->as<ast_import_directive>()->file);
break;
case ast_constant_declaration:
@@ -379,8 +253,8 @@ static void iterate_through_file_symbols(const SrcFile* file) {
}
}
-void pipeline_register_global_symbols(const AllSrcFiles& all_src_files) {
- for (const SrcFile* file : all_src_files) {
+void pipeline_register_global_symbols() {
+ for (const SrcFile* file : G.all_src_files) {
iterate_through_file_symbols(file);
}
}
diff --git a/tolk/pipe-resolve-identifiers.cpp b/tolk/pipe-resolve-identifiers.cpp
new file mode 100644
index 000000000..03b23c3c1
--- /dev/null
+++ b/tolk/pipe-resolve-identifiers.cpp
@@ -0,0 +1,347 @@
+/*
+ This file is part of TON Blockchain Library.
+
+ TON Blockchain Library is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Lesser General Public License as published by
+ the Free Software Foundation, either version 2 of the License, or
+ (at your option) any later version.
+
+ TON Blockchain Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public License
+ along with TON Blockchain Library. If not, see <http://www.gnu.org/licenses/>.
+*/
+#include "tolk.h"
+#include "platform-utils.h"
+#include "compiler-state.h"
+#include "src-file.h"
+#include "generics-helpers.h"
+#include "ast.h"
+#include "ast-visitor.h"
+#include "type-system.h"
+#include <unordered_map>
+
+/*
+ * This pipe resolves identifiers (local variables and types) in all functions bodies.
+ * It happens before type inferring, but after all global symbols are registered.
+ * It means, that for any symbol `x` we can look up whether it's a global name or not.
+ *
+ * About resolving variables.
+ * Example: `var x = 10; x = 20;` both `x` point to one LocalVarData.
+ * Example: `x = 20` undefined symbol `x` is also here (unless it's a global)
+ * Variables scoping and redeclaration are also here.
+ * Note, that `x` is stored as `ast_reference (ast_identifier "x")`. More formally, "references" are resolved.
+ * "Reference" in AST, besides the identifier, stores optional generics instantiation. `x<int>` is grammar-valid.
+ *
+ * About resolving types. At the moment of parsing, `int`, `cell` and other predefined are parsed as TypeDataInt, etc.
+ * All the others are stored as TypeDataUnresolved, to be resolved here, after global symtable is filled.
+ * Example: `var x: T = 0` unresolved "T" is replaced by TypeDataGenericT inside `f<T>`.
+ * Example: `f<MyAlias>()` unresolved "MyAlias" is replaced by TypeDataAlias inside the reference.
+ * Example: `fun f(): KKK` unresolved "KKK" fires an error "unknown type name".
+ * When structures and type aliases are implemented, their resolving will also be done here.
+ * See finalize_type_data().
+ *
+ * Note, that functions/methods binding is NOT here.
+ * In other words, for ast_function_call `beginCell()` and `t.tupleAt(0)`, their fun_ref is NOT filled here.
+ * Functions/methods binding is done later, simultaneously with type inferring and generics instantiation.
+ * For instance, to call a generic function `t.tuplePush(1)`, we need types of `t` and `1` to be inferred,
+ * as well as `tuplePush<int>` to be instantiated, and fun_ref to point at that exact instantiations.
+ *
+ * As a result of this step,
+ * * every V<ast_reference>::sym is filled, pointing either to a local var/parameter, or to a global symbol
+ * (exceptional for function calls and methods, their references are bound later)
+ * * all TypeData in all symbols is ready for analyzing, TypeDataUnresolved won't occur later in pipeline
+ */
+
+namespace tolk {
+
+GNU_ATTRIBUTE_NORETURN GNU_ATTRIBUTE_COLD
+static void fire_error_undefined_symbol(V<ast_identifier> v) {
+ if (v->name == "self") {
+ v->error("using `self` in a non-member function (it does not accept the first `self` parameter)");
+ } else {
+ v->error("undefined symbol `" + static_cast<std::string>(v->name) + "`");
+ }
+}
+
+GNU_ATTRIBUTE_NORETURN GNU_ATTRIBUTE_COLD
+static void fire_error_unknown_type_name(SrcLocation loc, const std::string &text) {
+ throw ParseError(loc, "unknown type name `" + text + "`");
+}
+
+static void check_import_exists_when_using_sym(AnyV v_usage, const Symbol* used_sym) {
+ SrcLocation sym_loc = used_sym->loc;
+ if (!v_usage->loc.is_symbol_from_same_or_builtin_file(sym_loc)) {
+ const SrcFile* declared_in = sym_loc.get_src_file();
+ bool has_import = false;
+ for (const SrcFile::ImportDirective& import : v_usage->loc.get_src_file()->imports) {
+ if (import.imported_file == declared_in) {
+ has_import = true;
+ }
+ }
+ if (!has_import) {
+ v_usage->error("Using a non-imported symbol `" + used_sym->name + "`. Forgot to import \"" + declared_in->rel_filename + "\"?");
+ }
+ }
+}
+
+struct NameAndScopeResolver {
+ std::vector<std::unordered_map<uint64_t, const Symbol*>> scopes;
+
+ static uint64_t key_hash(std::string_view name_key) {
+ return std::hash<std::string_view>{}(name_key);
+ }
+
+ void open_scope([[maybe_unused]] SrcLocation loc) {
+ // std::cerr << "open_scope " << scopes.size() + 1 << " at " << loc << std::endl;
+ scopes.emplace_back();
+ }
+
+ void close_scope([[maybe_unused]] SrcLocation loc) {
+ // std::cerr << "close_scope " << scopes.size() << " at " << loc << std::endl;
+ if (UNLIKELY(scopes.empty())) {
+ throw Fatal{"cannot close the outer scope"};
+ }
+ scopes.pop_back();
+ }
+
+ const Symbol* lookup_symbol(std::string_view name) const {
+ uint64_t key = key_hash(name);
+ for (auto it = scopes.rbegin(); it != scopes.rend(); ++it) { // NOLINT(*-loop-convert)
+ const auto& scope = *it;
+ if (auto it_sym = scope.find(key); it_sym != scope.end()) {
+ return it_sym->second;
+ }
+ }
+ return G.symtable.lookup(name);
+ }
+
+ void add_local_var(const LocalVarData* v_sym) {
+ if (UNLIKELY(scopes.empty())) {
+ throw Fatal("unexpected scope_level = 0");
+ }
+ if (v_sym->name.empty()) { // underscore
+ return;
+ }
+
+ uint64_t key = key_hash(v_sym->name);
+ const auto& [_, inserted] = scopes.rbegin()->emplace(key, v_sym);
+ if (UNLIKELY(!inserted)) {
+ throw ParseError(v_sym->loc, "redeclaration of local variable `" + v_sym->name + "`");
+ }
+ }
+};
+
+struct TypeDataResolver {
+ GNU_ATTRIBUTE_NOINLINE
+ static TypePtr resolve_identifiers_in_type_data(TypePtr type_data, const GenericsDeclaration* genericTs) {
+ return type_data->replace_children_custom([genericTs](TypePtr child) {
+ if (const TypeDataUnresolved* un = child->try_as<TypeDataUnresolved>()) {
+ if (genericTs && genericTs->has_nameT(un->text)) {
+ std::string nameT = un->text;
+ return TypeDataGenericT::create(std::move(nameT));
+ }
+ if (un->text == "auto") {
+ throw ParseError(un->loc, "`auto` type does not exist; just omit a type for local variable (will be inferred from assignment); parameters should always be typed");
+ }
+ if (un->text == "self") {
+ throw ParseError(un->loc, "`self` type can be used only as a return type of a function (enforcing it to be chainable)");
+ }
+ fire_error_unknown_type_name(un->loc, un->text);
+ }
+ return child;
+ });
+ }
+};
+
+static TypePtr finalize_type_data(TypePtr type_data, const GenericsDeclaration* genericTs) {
+ if (!type_data || !type_data->has_unresolved_inside()) {
+ return type_data;
+ }
+ return TypeDataResolver::resolve_identifiers_in_type_data(type_data, genericTs);
+}
+
+
+class AssignSymInsideFunctionVisitor final : public ASTVisitorFunctionBody {
+ // more correctly this field shouldn't be static, but currently there is no need to make it a part of state
+ static NameAndScopeResolver current_scope;
+ static const FunctionData* current_function;
+
+ static const LocalVarData* create_local_var_sym(std::string_view name, SrcLocation loc, TypePtr declared_type, bool immutable) {
+ LocalVarData* v_sym = new LocalVarData(static_cast<std::string>(name), loc, declared_type, immutable * LocalVarData::flagImmutable, -1);
+ current_scope.add_local_var(v_sym);
+ return v_sym;
+ }
+
+ static void process_catch_variable(AnyExprV catch_var) {
+ if (auto v_ref = catch_var->try_as<ast_reference>()) {
+ const LocalVarData* var_ref = create_local_var_sym(v_ref->get_name(), catch_var->loc, nullptr, true);
+ v_ref->mutate()->assign_sym(var_ref);
+ }
+ }
+
+protected:
+ void visit(V<ast_local_var_lhs> v) override {
+ if (v->marked_as_redef) {
+ const Symbol* sym = current_scope.lookup_symbol(v->get_name());
+ if (sym == nullptr) {
+ v->error("`redef` for unknown variable");
+ }
+ const LocalVarData* var_ref = sym->try_as<LocalVarData>();
+ if (!var_ref) {
+ v->error("`redef` for unknown variable");
+ }
+ v->mutate()->assign_var_ref(var_ref);
+ } else {
+ TypePtr declared_type = finalize_type_data(v->declared_type, current_function->genericTs);
+ const LocalVarData* var_ref = create_local_var_sym(v->get_name(), v->loc, declared_type, v->is_immutable);
+ v->mutate()->assign_resolved_type(declared_type);
+ v->mutate()->assign_var_ref(var_ref);
+ }
+ }
+
+ void visit(V<ast_assign> v) override {
+ parent::visit(v->get_rhs()); // in this order, so that `var x = x` is invalid, "x" on the right unknown
+ parent::visit(v->get_lhs());
+ }
+
+ void visit(V<ast_reference> v) override {
+ const Symbol* sym = current_scope.lookup_symbol(v->get_name());
+ if (!sym) {
+ fire_error_undefined_symbol(v->get_identifier());
+ }
+ v->mutate()->assign_sym(sym);
+
+ // for global functions, global vars and constants, `import` must exist
+ if (!sym->try_as<LocalVarData>()) {
+ check_import_exists_when_using_sym(v, sym);
+ }
+
+ // for `f<int, MyAlias>` / `f<T>`, resolve "MyAlias" and "T"
+ // (for function call `f<T>()`, this v (ast_reference `f<T>`) is callee)
+ if (auto v_instantiationTs = v->get_instantiationTs()) {
+ for (int i = 0; i < v_instantiationTs->size(); ++i) {
+ TypePtr substituted_type = finalize_type_data(v_instantiationTs->get_item(i)->substituted_type, current_function->genericTs);
+ v_instantiationTs->get_item(i)->mutate()->assign_resolved_type(substituted_type);
+ }
+ }
+ }
+
+ void visit(V<ast_dot_access> v) override {
+ // for `t.tupleAt<MyAlias>` / `obj.method<T>`, resolve "MyAlias" and "T"
+ // (for function call `t.tupleAt<MyAlias>()`, this v (ast_dot_access `t.tupleAt<MyAlias>`) is callee)
+ if (auto v_instantiationTs = v->get_instantiationTs()) {
+ for (int i = 0; i < v_instantiationTs->size(); ++i) {
+ TypePtr substituted_type = finalize_type_data(v_instantiationTs->get_item(i)->substituted_type, current_function->genericTs);
+ v_instantiationTs->get_item(i)->mutate()->assign_resolved_type(substituted_type);
+ }
+ }
+ parent::visit(v->get_obj());
+ }
+
+ void visit(V<ast_cast_as_operator> v) override {
+ TypePtr cast_to_type = finalize_type_data(v->cast_to_type, current_function->genericTs);
+ v->mutate()->assign_resolved_type(cast_to_type);
+ parent::visit(v->get_expr());
+ }
+
+ void visit(V<ast_sequence> v) override {
+ if (v->empty()) {
+ return;
+ }
+ current_scope.open_scope(v->loc);
+ parent::visit(v);
+ current_scope.close_scope(v->loc_end);
+ }
+
+ void visit(V<ast_do_while_statement> v) override {
+ current_scope.open_scope(v->loc);
+ parent::visit(v->get_body());
+ parent::visit(v->get_cond()); // in 'while' condition it's ok to use variables declared inside do
+ current_scope.close_scope(v->get_body()->loc_end);
+ }
+
+ void visit(V<ast_try_catch_statement> v) override {
+ visit(v->get_try_body());
+ current_scope.open_scope(v->get_catch_body()->loc);
+ const std::vector<AnyExprV>& catch_items = v->get_catch_expr()->get_items();
+ tolk_assert(catch_items.size() == 2);
+ process_catch_variable(catch_items[1]);
+ process_catch_variable(catch_items[0]);
+ parent::visit(v->get_catch_body());
+ current_scope.close_scope(v->get_catch_body()->loc_end);
+ }
+
+public:
+ bool should_visit_function(const FunctionData* fun_ref) override {
+ // this pipe is done just after parsing
+ // visit both asm and code functions, resolve identifiers in parameter/return types everywhere
+ // for generic functions, unresolved "T" will be replaced by TypeDataGenericT
+ return true;
+ }
+
+ void start_visiting_function(const FunctionData* fun_ref, V<ast_function_declaration> v) override {
+ current_function = fun_ref;
+
+ for (int i = 0; i < v->get_num_params(); ++i) {
+ const LocalVarData& param_var = fun_ref->parameters[i];
+ TypePtr declared_type = finalize_type_data(param_var.declared_type, fun_ref->genericTs);
+ v->get_param(i)->mutate()->assign_param_ref(¶m_var);
+ v->get_param(i)->mutate()->assign_resolved_type(declared_type);
+ param_var.mutate()->assign_resolved_type(declared_type);
+ }
+ TypePtr return_type = finalize_type_data(fun_ref->declared_return_type, fun_ref->genericTs);
+ v->mutate()->assign_resolved_type(return_type);
+ fun_ref->mutate()->assign_resolved_type(return_type);
+
+ if (fun_ref->is_code_function()) {
+ auto v_seq = v->get_body()->as<ast_sequence>();
+ current_scope.open_scope(v->loc);
+ for (int i = 0; i < v->get_num_params(); ++i) {
+ current_scope.add_local_var(&fun_ref->parameters[i]);
+ }
+ parent::visit(v_seq);
+ current_scope.close_scope(v_seq->loc_end);
+ tolk_assert(current_scope.scopes.empty());
+ }
+
+ current_function = nullptr;
+ }
+};
+
+NameAndScopeResolver AssignSymInsideFunctionVisitor::current_scope;
+const FunctionData* AssignSymInsideFunctionVisitor::current_function = nullptr;
+
+void pipeline_resolve_identifiers_and_assign_symbols() {
+ AssignSymInsideFunctionVisitor visitor;
+ for (const SrcFile* file : G.all_src_files) {
+ for (AnyV v : file->ast->as<ast_tolk_file>()->get_toplevel_declarations()) {
+ if (auto v_func = v->try_as<ast_function_declaration>()) {
+ tolk_assert(v_func->fun_ref);
+ visitor.start_visiting_function(v_func->fun_ref, v_func);
+
+ } else if (auto v_global = v->try_as<ast_global_var_declaration>()) {
+ TypePtr declared_type = finalize_type_data(v_global->var_ref->declared_type, nullptr);
+ v_global->mutate()->assign_resolved_type(declared_type);
+ v_global->var_ref->mutate()->assign_resolved_type(declared_type);
+
+ } else if (auto v_const = v->try_as<ast_constant_declaration>(); v_const && v_const->declared_type) {
+ TypePtr declared_type = finalize_type_data(v_const->const_ref->declared_type, nullptr);
+ v_const->mutate()->assign_resolved_type(declared_type);
+ v_const->const_ref->mutate()->assign_resolved_type(declared_type);
+ }
+ }
+ }
+}
+
+void pipeline_resolve_identifiers_and_assign_symbols(const FunctionData* fun_ref) {
+ AssignSymInsideFunctionVisitor visitor;
+ if (visitor.should_visit_function(fun_ref)) {
+ visitor.start_visiting_function(fun_ref, fun_ref->ast_root->as<ast_function_declaration>());
+ }
+}
+
+} // namespace tolk
diff --git a/tolk/pipeline.h b/tolk/pipeline.h
index fdfd2b996..6aec2b5e8 100644
--- a/tolk/pipeline.h
+++ b/tolk/pipeline.h
@@ -25,17 +25,34 @@
*/
#pragma once
-#include "src-file.h"
+#include "fwd-declarations.h"
#include <string>
namespace tolk {
-AllSrcFiles pipeline_discover_and_parse_sources(const std::string& stdlib_filename, const std::string& entrypoint_filename);
+void pipeline_discover_and_parse_sources(const std::string& stdlib_filename, const std::string& entrypoint_filename);
-void pipeline_register_global_symbols(const AllSrcFiles&);
-void pipeline_convert_ast_to_legacy_Expr_Op(const AllSrcFiles&);
+void pipeline_register_global_symbols();
+void pipeline_resolve_identifiers_and_assign_symbols();
+void pipeline_calculate_rvalue_lvalue();
+void pipeline_detect_unreachable_statements();
+void pipeline_infer_types_and_calls_and_fields();
+void pipeline_refine_lvalue_for_mutate_arguments();
+void pipeline_check_rvalue_lvalue();
+void pipeline_check_pure_impure_operations();
+void pipeline_constant_folding();
+void pipeline_optimize_boolean_expressions();
+void pipeline_convert_ast_to_legacy_Expr_Op();
void pipeline_find_unused_symbols();
-void pipeline_generate_fif_output_to_std_cout(const AllSrcFiles&);
+void pipeline_generate_fif_output_to_std_cout();
+
+// these pipes also can be called per-function individually
+// they are called for instantiated generics functions, when `f<T>` is deeply cloned as `f<int>`
+void pipeline_resolve_identifiers_and_assign_symbols(const FunctionData*);
+void pipeline_calculate_rvalue_lvalue(const FunctionData*);
+void pipeline_detect_unreachable_statements(const FunctionData*);
+void pipeline_infer_types_and_calls_and_fields(const FunctionData*);
+
} // namespace tolk
diff --git a/tolk/platform-utils.h b/tolk/platform-utils.h
index 7b16226e7..5ab01220e 100644
--- a/tolk/platform-utils.h
+++ b/tolk/platform-utils.h
@@ -27,11 +27,15 @@
#if __GNUC__
#define GNU_ATTRIBUTE_COLD [[gnu::cold]]
+#define GNU_ATTRIBUTE_FLATTEN [[gnu::flatten]]
#define GNU_ATTRIBUTE_NORETURN [[gnu::noreturn]]
+#define GNU_ATTRIBUTE_NOINLINE [[gnu::noinline]]
#define GNU_ATTRIBUTE_ALWAYS_INLINE [[gnu::always_inline]]
#else
#define GNU_ATTRIBUTE_COLD
+#define GNU_ATTRIBUTE_FLATTEN
#define GNU_ATTRIBUTE_NORETURN [[noreturn]]
+#define GNU_ATTRIBUTE_NOINLINE [[noinline]]
#define GNU_ATTRIBUTE_ALWAYS_INLINE
#endif
diff --git a/tolk/src-file.cpp b/tolk/src-file.cpp
index e5533f697..52ac38213 100644
--- a/tolk/src-file.cpp
+++ b/tolk/src-file.cpp
@@ -23,8 +23,8 @@ namespace tolk {
static_assert(sizeof(SrcLocation) == 8);
-SrcFile* AllRegisteredSrcFiles::find_file(int file_id) const {
- for (SrcFile* file : all_src_files) {
+const SrcFile* AllRegisteredSrcFiles::find_file(int file_id) const {
+ for (const SrcFile* file : all_src_files) {
if (file->file_id == file_id) {
return file;
}
@@ -32,8 +32,8 @@ SrcFile* AllRegisteredSrcFiles::find_file(int file_id) const {
return nullptr;
}
-SrcFile* AllRegisteredSrcFiles::find_file(const std::string& abs_filename) const {
- for (SrcFile* file : all_src_files) {
+const SrcFile* AllRegisteredSrcFiles::find_file(const std::string& abs_filename) const {
+ for (const SrcFile* file : all_src_files) {
if (file->abs_filename == abs_filename) {
return file;
}
@@ -41,7 +41,7 @@ SrcFile* AllRegisteredSrcFiles::find_file(const std::string& abs_filename) const
return nullptr;
}
-SrcFile* AllRegisteredSrcFiles::locate_and_register_source_file(const std::string& rel_filename, SrcLocation included_from) {
+const SrcFile* AllRegisteredSrcFiles::locate_and_register_source_file(const std::string& rel_filename, SrcLocation included_from) {
td::Result<std::string> path = G.settings.read_callback(CompilerSettings::FsReadCallbackKind::Realpath, rel_filename.c_str());
if (path.is_error()) {
if (included_from.is_defined()) {
@@ -51,7 +51,7 @@ SrcFile* AllRegisteredSrcFiles::locate_and_register_source_file(const std::strin
}
std::string abs_filename = path.move_as_ok();
- if (SrcFile* file = find_file(abs_filename)) {
+ if (const SrcFile* file = find_file(abs_filename)) {
return file;
}
@@ -75,16 +75,7 @@ SrcFile* AllRegisteredSrcFiles::get_next_unparsed_file() {
if (last_parsed_file_id >= last_registered_file_id) {
return nullptr;
}
- return all_src_files[++last_parsed_file_id];
-}
-
-AllSrcFiles AllRegisteredSrcFiles::get_all_files() const {
- AllSrcFiles src_files_immutable;
- src_files_immutable.reserve(all_src_files.size());
- for (const SrcFile* file : all_src_files) {
- src_files_immutable.push_back(file);
- }
- return src_files_immutable;
+ return const_cast<SrcFile*>(all_src_files[++last_parsed_file_id]);
}
bool SrcFile::is_stdlib_file() const {
diff --git a/tolk/src-file.h b/tolk/src-file.h
index 815dccbed..0c82bf180 100644
--- a/tolk/src-file.h
+++ b/tolk/src-file.h
@@ -18,11 +18,10 @@
#include <string>
#include <vector>
+#include "fwd-declarations.h"
namespace tolk {
-struct ASTNodeBase;
-
struct SrcFile {
struct SrcPosition {
int offset;
@@ -31,7 +30,7 @@ struct SrcFile {
std::string_view line_str;
};
- struct ImportStatement {
+ struct ImportDirective {
const SrcFile* imported_file;
};
@@ -39,8 +38,8 @@ struct SrcFile {
std::string rel_filename; // relative to cwd
std::string abs_filename; // absolute from root
std::string text; // file contents loaded into memory, every Token::str_val points inside it
- const ASTNodeBase* ast = nullptr; // when a file has been parsed, its ast_tolk_file is kept here
- std::vector<ImportStatement> imports; // to check strictness (can't use a symbol without importing its file)
+ AnyV ast = nullptr; // when a file has been parsed, its ast_tolk_file is kept here
+ std::vector<ImportDirective> imports; // to check strictness (can't use a symbol without importing its file)
SrcFile(int file_id, std::string rel_filename, std::string abs_filename, std::string&& text)
: file_id(file_id)
@@ -96,21 +95,20 @@ class SrcLocation {
std::ostream& operator<<(std::ostream& os, SrcLocation loc);
-using AllSrcFiles = std::vector<const SrcFile*>;
-
class AllRegisteredSrcFiles {
- std::vector<SrcFile*> all_src_files;
+ std::vector<const SrcFile*> all_src_files;
int last_registered_file_id = -1;
int last_parsed_file_id = -1;
public:
- SrcFile *find_file(int file_id) const;
- SrcFile* find_file(const std::string& abs_filename) const;
+ const SrcFile* find_file(int file_id) const;
+ const SrcFile* find_file(const std::string& abs_filename) const;
- SrcFile* locate_and_register_source_file(const std::string& rel_filename, SrcLocation included_from);
+ const SrcFile* locate_and_register_source_file(const std::string& rel_filename, SrcLocation included_from);
SrcFile* get_next_unparsed_file();
- AllSrcFiles get_all_files() const;
+ auto begin() const { return all_src_files.begin(); }
+ auto end() const { return all_src_files.end(); }
};
struct Fatal final : std::exception {
diff --git a/tolk/symtable.cpp b/tolk/symtable.cpp
index abaeb0846..918fdab33 100644
--- a/tolk/symtable.cpp
+++ b/tolk/symtable.cpp
@@ -16,154 +16,136 @@
*/
#include "symtable.h"
#include "compiler-state.h"
-#include <sstream>
-#include <cassert>
+#include "platform-utils.h"
+#include "generics-helpers.h"
namespace tolk {
-
-std::string Symbol::unknown_symbol_name(sym_idx_t i) {
- if (!i) {
- return "_";
- } else {
- std::ostringstream os;
- os << "SYM#" << i;
- return os.str();
+std::string FunctionData::as_human_readable() const {
+ if (!genericTs) {
+ return name; // if it's generic instantiation like `f<int>`, its name is "f<int>", not "f"
}
+ return name + genericTs->as_human_readable();
}
-sym_idx_t SymTable::gen_lookup(std::string_view str, int mode, sym_idx_t idx) {
- unsigned long long h1 = 1, h2 = 1;
- for (char c : str) {
- h1 = ((h1 * 239) + (unsigned char)(c)) % SIZE_PRIME;
- h2 = ((h2 * 17) + (unsigned char)(c)) % (SIZE_PRIME - 1);
+bool FunctionData::does_need_codegen() const {
+ // when a function is declared, but not referenced from code in any way, don't generate its body
+ if (!is_really_used() && G.settings.remove_unused_functions) {
+ return false;
+ }
+ // functions with asm body don't need code generation
+ // (even if used as non-call: `var a = beginCell;` inserts TVM continuation inline)
+ if (is_asm_function() || is_builtin_function()) {
+ return false;
+ }
+ // when a function is referenced like `var a = some_fn;` (or in some other non-call way), its continuation should exist
+ if (is_used_as_noncall()) {
+ return true;
}
- ++h2;
- ++h1;
- while (true) {
- if (sym[h1]) {
- if (sym[h1]->str == str) {
- return (mode & 2) ? not_found : sym_idx_t(h1);
- }
- h1 += h2;
- if (h1 > SIZE_PRIME) {
- h1 -= SIZE_PRIME;
- }
- } else {
- if (!(mode & 1)) {
- return not_found;
- }
- if (def_sym >= ((long long)SIZE_PRIME * 3) / 4) {
- throw SymTableOverflow{def_sym};
- }
- sym[h1] = std::make_unique<Symbol>(static_cast<std::string>(str), idx <= 0 ? sym_idx_t(h1) : -idx);
- ++def_sym;
- return sym_idx_t(h1);
- }
+ // generic functions also don't need code generation, only generic instantiations do
+ if (is_generic_function()) {
+ return false;
}
+ // currently, there is no inlining, all functions are codegenerated
+ // (but actually, unused ones are later removed by Fift)
+ // in the future, we may want to implement a true AST inlining for "simple" functions
+ return true;
}
-std::string SymDef::name() const {
- return G.symbols.get_name(sym_idx);
+void FunctionData::assign_resolved_type(TypePtr declared_return_type) {
+ this->declared_return_type = declared_return_type;
}
-void open_scope(SrcLocation loc) {
- ++G.scope_level;
- G.scope_opened_at.push_back(loc);
+void FunctionData::assign_inferred_type(TypePtr inferred_return_type, TypePtr inferred_full_type) {
+ this->inferred_return_type = inferred_return_type;
+ this->inferred_full_type = inferred_full_type;
}
-void close_scope() {
- if (!G.scope_level) {
- throw Fatal{"cannot close the outer scope"};
- }
- while (!G.symbol_stack.empty() && G.symbol_stack.back().first == G.scope_level) {
- SymDef old_def = G.symbol_stack.back().second;
- auto idx = old_def.sym_idx;
- G.symbol_stack.pop_back();
- SymDef* cur_def = G.sym_def[idx];
- assert(cur_def);
- assert(cur_def->level == G.scope_level && cur_def->sym_idx == idx);
- //std::cerr << "restoring local symbol `" << old_def.name << "` of level " << scope_level << " to its previous level " << old_def.level << std::endl;
- if (cur_def->value) {
- //std::cerr << "deleting value of symbol " << old_def.name << ":" << old_def.level << " at " << (const void*) it->second.value << std::endl;
- delete cur_def->value;
- }
- if (!old_def.level && !old_def.value) {
- delete cur_def; // ??? keep the definition always?
- G.sym_def[idx] = nullptr;
- } else {
- cur_def->value = old_def.value;
- cur_def->level = old_def.level;
- }
- old_def.value = nullptr;
- }
- --G.scope_level;
- G.scope_opened_at.pop_back();
+void FunctionData::assign_is_used_as_noncall() {
+ this->flags |= flagUsedAsNonCall;
}
-SymDef* lookup_symbol(sym_idx_t idx) {
- if (!idx) {
- return nullptr;
- }
- if (G.sym_def[idx]) {
- return G.sym_def[idx];
- }
- if (G.global_sym_def[idx]) {
- return G.global_sym_def[idx];
- }
- return nullptr;
+void FunctionData::assign_is_implicit_return() {
+ this->flags |= flagImplicitReturn;
}
-SymDef* define_global_symbol(sym_idx_t name_idx, SrcLocation loc) {
- if (SymDef* found = G.global_sym_def[name_idx]) {
- return found; // found->value is filled; it means, that a symbol is redefined
- }
+void FunctionData::assign_is_type_inferring_done() {
+ this->flags |= flagTypeInferringDone;
+}
- SymDef* registered = G.global_sym_def[name_idx] = new SymDef(0, name_idx, loc);
-#ifdef TOLK_DEBUG
- registered->sym_name = registered->name();
-#endif
- return registered; // registered->value is nullptr; it means, it's just created
+void FunctionData::assign_is_really_used() {
+ this->flags |= flagReallyUsed;
}
-SymDef* define_parameter(sym_idx_t name_idx, SrcLocation loc) {
- // note, that parameters (defined at function declaration) are not inserted into symtable
- // their SymDef is registered to be inserted into SymValFunc::parameters
- // (and later ->value is filled with SymValVariable)
+void FunctionData::assign_arg_order(std::vector<int>&& arg_order) {
+ this->arg_order = std::move(arg_order);
+}
- SymDef* registered = new SymDef(0, name_idx, loc);
+void GlobalVarData::assign_resolved_type(TypePtr declared_type) {
+ this->declared_type = declared_type;
+}
+
+void GlobalVarData::assign_is_really_used() {
+ this->flags |= flagReallyUsed;
+}
+
+void GlobalConstData::assign_resolved_type(TypePtr declared_type) {
+ this->declared_type = declared_type;
+}
+
+void LocalVarData::assign_idx(int idx) {
+ this->idx = idx;
+}
+
+void LocalVarData::assign_resolved_type(TypePtr declared_type) {
+ this->declared_type = declared_type;
+}
+
+void LocalVarData::assign_inferred_type(TypePtr inferred_type) {
#ifdef TOLK_DEBUG
- registered->sym_name = registered->name();
+ assert(this->declared_type == nullptr); // called when type declaration omitted, inferred from assigned value
#endif
- return registered;
+ this->declared_type = inferred_type;
}
-SymDef* define_symbol(sym_idx_t name_idx, bool force_new, SrcLocation loc) {
- if (!name_idx) {
- return nullptr;
+GNU_ATTRIBUTE_NORETURN GNU_ATTRIBUTE_COLD
+static void fire_error_redefinition_of_symbol(SrcLocation loc, const Symbol* previous) {
+ SrcLocation prev_loc = previous->loc;
+ if (prev_loc.is_stdlib()) {
+ throw ParseError(loc, "redefinition of a symbol from stdlib");
}
- if (!G.scope_level) {
- throw Fatal("unexpected scope_level = 0");
+ if (prev_loc.is_defined()) {
+ throw ParseError(loc, "redefinition of symbol, previous was at: " + prev_loc.to_string());
}
- auto found = G.sym_def[name_idx];
- if (found) {
- if (found->level < G.scope_level) {
- G.symbol_stack.emplace_back(G.scope_level, *found);
- found->level = G.scope_level;
- } else if (found->value && force_new) {
- return nullptr;
- }
- found->value = nullptr;
- found->loc = loc;
- return found;
+ throw ParseError(loc, "redefinition of built-in symbol");
+}
+
+void GlobalSymbolTable::add_function(const FunctionData* f_sym) {
+ auto key = key_hash(f_sym->name);
+ auto [it, inserted] = entries.emplace(key, f_sym);
+ if (!inserted) {
+ fire_error_redefinition_of_symbol(f_sym->loc, it->second);
}
- found = G.sym_def[name_idx] = new SymDef(G.scope_level, name_idx, loc);
- G.symbol_stack.emplace_back(G.scope_level, SymDef{0, name_idx, loc});
-#ifdef TOLK_DEBUG
- found->sym_name = found->name();
- G.symbol_stack.back().second.sym_name = found->name();
-#endif
- return found;
+}
+
+void GlobalSymbolTable::add_global_var(const GlobalVarData* g_sym) {
+ auto key = key_hash(g_sym->name);
+ auto [it, inserted] = entries.emplace(key, g_sym);
+ if (!inserted) {
+ fire_error_redefinition_of_symbol(g_sym->loc, it->second);
+ }
+}
+
+void GlobalSymbolTable::add_global_const(const GlobalConstData* c_sym) {
+ auto key = key_hash(c_sym->name);
+ auto [it, inserted] = entries.emplace(key, c_sym);
+ if (!inserted) {
+ fire_error_redefinition_of_symbol(c_sym->loc, it->second);
+ }
+}
+
+const Symbol* lookup_global_symbol(std::string_view name) {
+ return G.symtable.lookup(name);
}
} // namespace tolk
diff --git a/tolk/symtable.h b/tolk/symtable.h
index 69e2eaa8e..3cda24edf 100644
--- a/tolk/symtable.h
+++ b/tolk/symtable.h
@@ -17,98 +17,225 @@
#pragma once
#include "src-file.h"
-#include "type-expr.h"
-#include <functional>
-#include <memory>
+#include "fwd-declarations.h"
+#include "constant-evaluator.h"
+#include "crypto/common/refint.h"
+#include <unordered_map>
+#include <variant>
+#include <vector>
namespace tolk {
-typedef int var_idx_t;
-typedef int sym_idx_t;
+struct Symbol {
+ std::string name;
+ SrcLocation loc;
-enum class SymValKind { _Var, _Func, _GlobVar, _Const };
+ Symbol(std::string name, SrcLocation loc)
+ : name(std::move(name))
+ , loc(loc) {
+ }
-struct SymValBase {
- SymValKind kind;
- int idx;
- TypeExpr* sym_type;
+ virtual ~Symbol() = default;
+
+ template<class T>
+ const T* as() const {
#ifdef TOLK_DEBUG
- std::string sym_name; // seeing symbol name in debugger makes it much easier to delve into Tolk sources
+ assert(dynamic_cast<const T*>(this) != nullptr);
#endif
-
- SymValBase(SymValKind kind, int idx, TypeExpr* sym_type) : kind(kind), idx(idx), sym_type(sym_type) {
+ return dynamic_cast<const T*>(this);
}
- virtual ~SymValBase() = default;
- TypeExpr* get_type() const {
- return sym_type;
+ template<class T>
+ const T* try_as() const {
+ return dynamic_cast<const T*>(this);
}
};
+struct LocalVarData final : Symbol {
+ enum {
+ flagMutateParameter = 1, // parameter was declared with `mutate` keyword
+ flagImmutable = 2, // variable was declared via `val` (not `var`)
+ };
-struct Symbol {
- std::string str;
- sym_idx_t idx;
+ TypePtr declared_type; // either at declaration `var x:int`, or if omitted, from assigned value `var x=2`
+ int flags;
+ int idx;
- Symbol(std::string str, sym_idx_t idx) : str(std::move(str)), idx(idx) {}
+ LocalVarData(std::string name, SrcLocation loc, TypePtr declared_type, int flags, int idx)
+ : Symbol(std::move(name), loc)
+ , declared_type(declared_type)
+ , flags(flags)
+ , idx(idx) {
+ }
- static std::string unknown_symbol_name(sym_idx_t i);
-};
+ bool is_immutable() const { return flags & flagImmutable; }
+ bool is_mutate_parameter() const { return flags & flagMutateParameter; }
-class SymTable {
-public:
- static constexpr int SIZE_PRIME = 100003;
+ LocalVarData* mutate() const { return const_cast<LocalVarData*>(this); }
+ void assign_idx(int idx);
+ void assign_resolved_type(TypePtr declared_type);
+ void assign_inferred_type(TypePtr inferred_type);
+};
-private:
- sym_idx_t def_sym{0};
- std::unique_ptr<Symbol> sym[SIZE_PRIME + 1];
- sym_idx_t gen_lookup(std::string_view str, int mode = 0, sym_idx_t idx = 0);
+struct FunctionBodyCode;
+struct FunctionBodyAsm;
+struct FunctionBodyBuiltin;
+struct GenericsDeclaration;
+struct GenericsInstantiation;
+
+typedef std::variant<
+ FunctionBodyCode*,
+ FunctionBodyAsm*,
+ FunctionBodyBuiltin*
+> FunctionBody;
+
+struct FunctionData final : Symbol {
+ static constexpr int EMPTY_METHOD_ID = -10;
+
+ enum {
+ flagInline = 1, // marked `@inline`
+ flagInlineRef = 2, // marked `@inline_ref`
+ flagTypeInferringDone = 4, // type inferring step of function's body (all AST nodes assigning v->inferred_type) is done
+ flagUsedAsNonCall = 8, // used not only as `f()`, but as a 1-st class function (assigned to var, pushed to tuple, etc.)
+ flagMarkedAsPure = 16, // declared as `pure`, can't call impure and access globals, unused invocations are optimized out
+ flagImplicitReturn = 32, // control flow reaches end of function, so it needs implicit return at the end
+ flagGetMethod = 64, // was declared via `get func(): T`, method_id is auto-assigned
+ flagIsEntrypoint = 128, // it's `main` / `onExternalMessage` / etc.
+ flagHasMutateParams = 256, // has parameters declared as `mutate`
+ flagAcceptsSelf = 512, // is a member function (has `self` first parameter)
+ flagReturnsSelf = 1024, // return type is `self` (returns the mutated 1st argument), calls can be chainable
+ flagReallyUsed = 2048, // calculated via dfs from used functions; declared but unused functions are not codegenerated
+ };
+
+ int method_id = EMPTY_METHOD_ID;
+ int flags;
+
+ std::vector<LocalVarData> parameters;
+ std::vector<int> arg_order, ret_order;
+ TypePtr declared_return_type; // may be nullptr, meaning "auto infer"
+ TypePtr inferred_return_type = nullptr; // assigned on type inferring
+ TypePtr inferred_full_type = nullptr; // assigned on type inferring, it's TypeDataFunCallable(params -> return)
+
+ const GenericsDeclaration* genericTs;
+ const GenericsInstantiation* instantiationTs;
+ FunctionBody body;
+ AnyV ast_root; // V<ast_function_declaration> for user-defined (not builtin)
+
+ FunctionData(std::string name, SrcLocation loc, TypePtr declared_return_type, std::vector<LocalVarData> parameters, int initial_flags, const GenericsDeclaration* genericTs, const GenericsInstantiation* instantiationTs, FunctionBody body, AnyV ast_root)
+ : Symbol(std::move(name), loc)
+ , flags(initial_flags)
+ , parameters(std::move(parameters))
+ , declared_return_type(declared_return_type)
+ , genericTs(genericTs)
+ , instantiationTs(instantiationTs)
+ , body(body)
+ , ast_root(ast_root) {
+ }
-public:
+ std::string as_human_readable() const;
- static constexpr sym_idx_t not_found = 0;
- sym_idx_t lookup(std::string_view str) {
- return gen_lookup(str, 0);
- }
- sym_idx_t lookup_add(std::string_view str) {
- return gen_lookup(str, 1);
+ const std::vector<int>* get_arg_order() const {
+ return arg_order.empty() ? nullptr : &arg_order;
}
- Symbol* operator[](sym_idx_t i) const {
- return sym[i].get();
- }
- std::string get_name(sym_idx_t i) const {
- return sym[i] ? sym[i]->str : Symbol::unknown_symbol_name(i);
+ const std::vector<int>* get_ret_order() const {
+ return ret_order.empty() ? nullptr : &ret_order;
}
+
+ int get_num_params() const { return static_cast<int>(parameters.size()); }
+ const LocalVarData& get_param(int idx) const { return parameters[idx]; }
+
+ bool is_code_function() const { return std::holds_alternative<FunctionBodyCode*>(body); }
+ bool is_asm_function() const { return std::holds_alternative<FunctionBodyAsm*>(body); }
+ bool is_builtin_function() const { return ast_root == nullptr; }
+
+ bool is_generic_function() const { return genericTs != nullptr; }
+ bool is_instantiation_of_generic_function() const { return instantiationTs != nullptr; }
+
+ bool is_inline() const { return flags & flagInline; }
+ bool is_inline_ref() const { return flags & flagInlineRef; }
+ bool is_type_inferring_done() const { return flags & flagTypeInferringDone; }
+ bool is_used_as_noncall() const { return flags & flagUsedAsNonCall; }
+ bool is_marked_as_pure() const { return flags & flagMarkedAsPure; }
+ bool is_implicit_return() const { return flags & flagImplicitReturn; }
+ bool is_get_method() const { return flags & flagGetMethod; }
+ bool is_method_id_not_empty() const { return method_id != EMPTY_METHOD_ID; }
+ bool is_entrypoint() const { return flags & flagIsEntrypoint; }
+ bool has_mutate_params() const { return flags & flagHasMutateParams; }
+ bool does_accept_self() const { return flags & flagAcceptsSelf; }
+ bool does_return_self() const { return flags & flagReturnsSelf; }
+ bool does_mutate_self() const { return (flags & flagAcceptsSelf) && parameters[0].is_mutate_parameter(); }
+ bool is_really_used() const { return flags & flagReallyUsed; }
+
+ bool does_need_codegen() const;
+
+ FunctionData* mutate() const { return const_cast<FunctionData*>(this); }
+ void assign_resolved_type(TypePtr declared_return_type);
+ void assign_inferred_type(TypePtr inferred_return_type, TypePtr inferred_full_type);
+ void assign_is_used_as_noncall();
+ void assign_is_implicit_return();
+ void assign_is_type_inferring_done();
+ void assign_is_really_used();
+ void assign_arg_order(std::vector<int>&& arg_order);
};
-struct SymTableOverflow {
- int sym_def;
- explicit SymTableOverflow(int x) : sym_def(x) {
+struct GlobalVarData final : Symbol {
+ enum {
+ flagReallyUsed = 1, // calculated via dfs from used functions; unused globals are not codegenerated
+ };
+
+ TypePtr declared_type; // always exists, declaring globals without type is prohibited
+ int flags = 0;
+
+ GlobalVarData(std::string name, SrcLocation loc, TypePtr declared_type)
+ : Symbol(std::move(name), loc)
+ , declared_type(declared_type) {
}
+
+ bool is_really_used() const { return flags & flagReallyUsed; }
+
+ GlobalVarData* mutate() const { return const_cast<GlobalVarData*>(this); }
+ void assign_resolved_type(TypePtr declared_type);
+ void assign_is_really_used();
};
+struct GlobalConstData final : Symbol {
+ ConstantValue value;
+ TypePtr declared_type; // may be nullptr
-struct SymDef {
- int level;
- sym_idx_t sym_idx;
- SymValBase* value;
- SrcLocation loc;
-#ifdef TOLK_DEBUG
- std::string sym_name;
-#endif
- SymDef(int lvl, sym_idx_t idx, SrcLocation _loc, SymValBase* val = nullptr)
- : level(lvl), sym_idx(idx), value(val), loc(_loc) {
+ GlobalConstData(std::string name, SrcLocation loc, TypePtr declared_type, ConstantValue&& value)
+ : Symbol(std::move(name), loc)
+ , value(std::move(value))
+ , declared_type(declared_type) {
}
- std::string name() const;
+
+ bool is_int_const() const { return value.is_int(); }
+ bool is_slice_const() const { return value.is_slice(); }
+
+ td::RefInt256 as_int_const() const { return value.as_int(); }
+ const std::string& as_slice_const() const { return value.as_slice(); }
+
+ GlobalConstData* mutate() const { return const_cast<GlobalConstData*>(this); }
+ void assign_resolved_type(TypePtr declared_type);
};
+class GlobalSymbolTable {
+ std::unordered_map<uint64_t, const Symbol*> entries;
+
+ static uint64_t key_hash(std::string_view name_key) {
+ return std::hash<std::string_view>{}(name_key);
+ }
+
+public:
+ void add_function(const FunctionData* f_sym);
+ void add_global_var(const GlobalVarData* g_sym);
+ void add_global_const(const GlobalConstData* c_sym);
-void open_scope(SrcLocation loc);
-void close_scope();
-SymDef* lookup_symbol(sym_idx_t idx);
+ const Symbol* lookup(std::string_view name) const {
+ const auto it = entries.find(key_hash(name));
+ return it == entries.end() ? nullptr : it->second;
+ }
+};
-SymDef* define_global_symbol(sym_idx_t name_idx, SrcLocation loc = {});
-SymDef* define_parameter(sym_idx_t name_idx, SrcLocation loc);
-SymDef* define_symbol(sym_idx_t name_idx, bool force_new, SrcLocation loc);
+const Symbol* lookup_global_symbol(std::string_view name);
} // namespace tolk
diff --git a/tolk/tolk-version.h b/tolk/tolk-version.h
index 6e5b764ca..7eaf55a7a 100644
--- a/tolk/tolk-version.h
+++ b/tolk/tolk-version.h
@@ -18,6 +18,6 @@
namespace tolk {
-constexpr const char* TOLK_VERSION = "0.6.0";
+constexpr const char* TOLK_VERSION = "0.7.0";
} // namespace tolk
diff --git a/tolk/tolk.cpp b/tolk/tolk.cpp
index 9268cc62d..cc867c521 100644
--- a/tolk/tolk.cpp
+++ b/tolk/tolk.cpp
@@ -28,6 +28,7 @@
#include "compiler-state.h"
#include "lexer.h"
#include "ast.h"
+#include "type-system.h"
namespace tolk {
@@ -45,19 +46,29 @@ void on_assertion_failed(const char *description, const char *file_name, int lin
}
int tolk_proceed(const std::string &entrypoint_filename) {
+ type_system_init();
define_builtins();
lexer_init();
// on any error, an exception is thrown, and the message is printed out below
// (currently, only a single error can be printed)
try {
- AllSrcFiles all_files = pipeline_discover_and_parse_sources("@stdlib/common.tolk", entrypoint_filename);
+ pipeline_discover_and_parse_sources("@stdlib/common.tolk", entrypoint_filename);
- pipeline_register_global_symbols(all_files);
- pipeline_convert_ast_to_legacy_Expr_Op(all_files);
+ pipeline_register_global_symbols();
+ pipeline_resolve_identifiers_and_assign_symbols();
+ pipeline_calculate_rvalue_lvalue();
+ pipeline_detect_unreachable_statements();
+ pipeline_infer_types_and_calls_and_fields();
+ pipeline_refine_lvalue_for_mutate_arguments();
+ pipeline_check_rvalue_lvalue();
+ pipeline_check_pure_impure_operations();
+ pipeline_constant_folding();
+ pipeline_optimize_boolean_expressions();
+ pipeline_convert_ast_to_legacy_Expr_Op();
pipeline_find_unused_symbols();
- pipeline_generate_fif_output_to_std_cout(all_files);
+ pipeline_generate_fif_output_to_std_cout();
return 0;
} catch (Fatal& fatal) {
@@ -66,11 +77,6 @@ int tolk_proceed(const std::string &entrypoint_filename) {
} catch (ParseError& error) {
std::cerr << error << std::endl;
return 2;
- } catch (UnifyError& unif_err) {
- std::cerr << "fatal: ";
- unif_err.print_message(std::cerr);
- std::cerr << std::endl;
- return 2;
} catch (UnexpectedASTNodeType& error) {
std::cerr << "fatal: " << error.what() << std::endl;
std::cerr << "It's a compiler bug, please report to developers" << std::endl;
diff --git a/tolk/tolk.h b/tolk/tolk.h
index 971ca35dd..5ec4d3e08 100644
--- a/tolk/tolk.h
+++ b/tolk/tolk.h
@@ -18,10 +18,10 @@
#include "platform-utils.h"
#include "src-file.h"
-#include "type-expr.h"
#include "symtable.h"
#include "crypto/common/refint.h"
#include "td/utils/Status.h"
+#include <functional>
#include <vector>
#include <string>
#include <stack>
@@ -34,52 +34,33 @@ namespace tolk {
GNU_ATTRIBUTE_COLD GNU_ATTRIBUTE_NORETURN
void on_assertion_failed(const char *description, const char *file_name, int line_number);
-/*
- *
- * TYPE EXPRESSIONS
- *
- */
-
-struct UnifyError : std::exception {
- TypeExpr* te1;
- TypeExpr* te2;
- std::string msg;
-
- UnifyError(TypeExpr* _te1, TypeExpr* _te2, std::string _msg = "") : te1(_te1), te2(_te2), msg(std::move(_msg)) {
- }
-
- void print_message(std::ostream& os) const;
- const char* what() const noexcept override {
- return msg.c_str();
- }
-};
-
-std::ostream& operator<<(std::ostream& os, const UnifyError& ue);
-
-void unify(TypeExpr*& te1, TypeExpr*& te2);
-
/*
*
* ABSTRACT CODE
*
*/
-using const_idx_t = int;
+typedef int var_idx_t;
+typedef int const_idx_t;
struct TmpVar {
- TypeExpr* v_type;
+ TypePtr v_type;
var_idx_t idx;
- sym_idx_t sym_idx;
+ const LocalVarData* v_sym; // points to var defined in code; nullptr for implicitly created tmp vars
int coord;
SrcLocation where;
std::vector<std::function<void(SrcLocation)>> on_modification;
- TmpVar(var_idx_t _idx, TypeExpr* _type, sym_idx_t sym_idx, SrcLocation loc);
- bool is_unnamed() const { return sym_idx == 0; }
+ TmpVar(var_idx_t _idx, TypePtr type, const LocalVarData* v_sym, SrcLocation loc)
+ : v_type(type)
+ , idx(_idx)
+ , v_sym(v_sym)
+ , coord(0)
+ , where(loc) {
+ }
void show(std::ostream& os, int omit_idx = 0) const;
void dump(std::ostream& os) const;
- void set_location(SrcLocation loc);
};
struct VarDescr {
@@ -171,7 +152,6 @@ struct VarDescr {
void set_const(long long value);
void set_const(td::RefInt256 value);
void set_const(std::string value);
- void set_const_nan();
void operator+=(const VarDescr& y) {
flags &= y.flags;
}
@@ -303,7 +283,8 @@ struct Op {
enum { _Disabled = 1, _NoReturn = 4, _Impure = 24 };
int flags;
std::unique_ptr<Op> next;
- SymDef* fun_ref; // despite its name, it may actually ref global var; applicable not only to Op::_Call, but for other kinds also
+ const FunctionData* f_sym = nullptr;
+ const GlobalVarData* g_sym = nullptr;
SrcLocation where;
VarDescrList var_info;
std::vector<VarDescr> args;
@@ -311,27 +292,41 @@ struct Op {
std::unique_ptr<Op> block0, block1;
td::RefInt256 int_const;
std::string str_const;
- Op(SrcLocation _where = {}, OpKind _cl = _Undef) : cl(_cl), flags(0), fun_ref(nullptr), where(_where) {
+ Op(SrcLocation _where = {}, OpKind _cl = _Undef) : cl(_cl), flags(0), f_sym(nullptr), where(_where) {
}
Op(SrcLocation _where, OpKind _cl, const std::vector<var_idx_t>& _left)
- : cl(_cl), flags(0), fun_ref(nullptr), where(_where), left(_left) {
+ : cl(_cl), flags(0), f_sym(nullptr), where(_where), left(_left) {
}
Op(SrcLocation _where, OpKind _cl, std::vector<var_idx_t>&& _left)
- : cl(_cl), flags(0), fun_ref(nullptr), where(_where), left(std::move(_left)) {
+ : cl(_cl), flags(0), f_sym(nullptr), where(_where), left(std::move(_left)) {
}
Op(SrcLocation _where, OpKind _cl, const std::vector<var_idx_t>& _left, td::RefInt256 _const)
- : cl(_cl), flags(0), fun_ref(nullptr), where(_where), left(_left), int_const(_const) {
+ : cl(_cl), flags(0), f_sym(nullptr), where(_where), left(_left), int_const(_const) {
}
Op(SrcLocation _where, OpKind _cl, const std::vector<var_idx_t>& _left, std::string _const)
- : cl(_cl), flags(0), fun_ref(nullptr), where(_where), left(_left), str_const(_const) {
+ : cl(_cl), flags(0), f_sym(nullptr), where(_where), left(_left), str_const(_const) {
+ }
+ Op(SrcLocation _where, OpKind _cl, const std::vector<var_idx_t>& _left, const std::vector<var_idx_t>& _right)
+ : cl(_cl), flags(0), f_sym(nullptr), where(_where), left(_left), right(_right) {
+ }
+ Op(SrcLocation _where, OpKind _cl, std::vector<var_idx_t>&& _left, std::vector<var_idx_t>&& _right)
+ : cl(_cl), flags(0), f_sym(nullptr), where(_where), left(std::move(_left)), right(std::move(_right)) {
}
Op(SrcLocation _where, OpKind _cl, const std::vector<var_idx_t>& _left, const std::vector<var_idx_t>& _right,
- SymDef* _fun = nullptr)
- : cl(_cl), flags(0), fun_ref(_fun), where(_where), left(_left), right(_right) {
+ const FunctionData* _fun)
+ : cl(_cl), flags(0), f_sym(_fun), where(_where), left(_left), right(_right) {
}
Op(SrcLocation _where, OpKind _cl, std::vector<var_idx_t>&& _left, std::vector<var_idx_t>&& _right,
- SymDef* _fun = nullptr)
- : cl(_cl), flags(0), fun_ref(_fun), where(_where), left(std::move(_left)), right(std::move(_right)) {
+ const FunctionData* _fun)
+ : cl(_cl), flags(0), f_sym(_fun), where(_where), left(std::move(_left)), right(std::move(_right)) {
+ }
+ Op(SrcLocation _where, OpKind _cl, const std::vector<var_idx_t>& _left, const std::vector<var_idx_t>& _right,
+ const GlobalVarData* _gvar)
+ : cl(_cl), flags(0), g_sym(_gvar), where(_where), left(_left), right(_right) {
+ }
+ Op(SrcLocation _where, OpKind _cl, std::vector<var_idx_t>&& _left, std::vector<var_idx_t>&& _right,
+ const GlobalVarData* _gvar)
+ : cl(_cl), flags(0), g_sym(_gvar), where(_where), left(std::move(_left)), right(std::move(_right)) {
}
bool disabled() const { return flags & _Disabled; }
@@ -343,8 +338,7 @@ struct Op {
bool set_noreturn(bool flag);
bool impure() const { return flags & _Impure; }
- void set_impure(const CodeBlob &code);
- void set_impure(const CodeBlob &code, bool flag);
+ void set_impure_flag();
void show(std::ostream& os, const std::vector<TmpVar>& vars, std::string pfx = "", int mode = 0) const;
void show_var_list(std::ostream& os, const std::vector<var_idx_t>& idx_list, const std::vector<TmpVar>& vars) const;
@@ -391,247 +385,16 @@ inline ListIterator<const Op> end(const Op* op_list) {
return ListIterator<const Op>{};
}
-typedef std::tuple<TypeExpr*, SymDef*, SrcLocation> FormalArg;
+typedef std::tuple<TypePtr, const LocalVarData*, SrcLocation> FormalArg;
typedef std::vector<FormalArg> FormalArgList;
struct AsmOpList;
-/*
- *
- * SYMBOL VALUES
- *
- */
-
-struct SymValVariable : SymValBase {
- enum SymValFlag {
- flagMutateParameter = 1, // parameter was declared with `mutate` keyword
- flagImmutable = 2, // variable was declared via `val` (not `var`)
- };
- int flags{0};
-
- ~SymValVariable() override = default;
- SymValVariable(int val, TypeExpr* sym_type)
- : SymValBase(SymValKind::_Var, val, sym_type) {}
-
- bool is_function_parameter() const {
- return idx >= 0;
- }
- bool is_mutate_parameter() const {
- return flags & flagMutateParameter;
- }
- bool is_local_var() const {
- return idx == -1;
- }
- bool is_immutable() const {
- return flags & flagImmutable;
- }
-};
-
-struct SymValFunc : SymValBase {
- enum SymValFlag {
- flagInline = 1, // marked `@inline`
- flagInlineRef = 2, // marked `@inline_ref`
- flagUsedAsNonCall = 8, // used not only as `f()`, but as a 1-st class function (assigned to var, pushed to tuple, etc.)
- flagMarkedAsPure = 16, // declared as `pure`, can't call impure and access globals, unused invocations are optimized out
- flagBuiltinFunction = 32, // was created via `define_builtin_func()`, not from source code
- flagGetMethod = 64, // was declared via `get func(): T`, method_id is auto-assigned
- flagIsEntrypoint = 128, // it's `main` / `onExternalMessage` / etc.
- flagHasMutateParams = 256, // has parameters declared as `mutate`
- flagAcceptsSelf = 512, // is a member function (has `self` first parameter)
- flagReturnsSelf = 1024, // return type is `self` (returns the mutated 1st argument), calls can be chainable
- };
-
- td::RefInt256 method_id; // todo why int256? it's small
- int flags{0};
- std::vector<SymDef*> parameters; // [i]-th may be nullptr for underscore; if not, its val is SymValVariable
- std::vector<int> arg_order, ret_order;
-
- ~SymValFunc() override = default;
- SymValFunc(std::vector<SymDef*> parameters, int val, TypeExpr* sym_type, int flags)
- : SymValBase(SymValKind::_Func, val, sym_type), flags(flags), parameters(std::move(parameters)) {
- }
- SymValFunc(std::vector<SymDef*> parameters, int val, TypeExpr* sym_type, int flags, std::initializer_list<int> arg_order, std::initializer_list<int> ret_order)
- : SymValBase(SymValKind::_Func, val, sym_type), flags(flags), parameters(std::move(parameters)), arg_order(arg_order), ret_order(ret_order) {
- }
-
- const std::vector<int>* get_arg_order() const {
- return arg_order.empty() ? nullptr : &arg_order;
- }
- const std::vector<int>* get_ret_order() const {
- return ret_order.empty() ? nullptr : &ret_order;
- }
-
- bool is_inline() const {
- return flags & flagInline;
- }
- bool is_inline_ref() const {
- return flags & flagInlineRef;
- }
- bool is_marked_as_pure() const {
- return flags & flagMarkedAsPure;
- }
- bool is_builtin() const {
- return flags & flagBuiltinFunction;
- }
- bool is_get_method() const {
- return flags & flagGetMethod;
- }
- bool is_entrypoint() const {
- return flags & flagIsEntrypoint;
- }
- bool has_mutate_params() const {
- return flags & flagHasMutateParams;
- }
- bool does_accept_self() const {
- return flags & flagAcceptsSelf;
- }
- bool does_return_self() const {
- return flags & flagReturnsSelf;
- }
-};
-
-struct SymValCodeFunc : SymValFunc {
- CodeBlob* code;
- bool is_really_used{false}; // calculated via dfs; unused functions are not codegenerated
- ~SymValCodeFunc() override = default;
- SymValCodeFunc(std::vector<SymDef*> parameters, int val, TypeExpr* _ft)
- : SymValFunc(std::move(parameters), val, _ft, 0), code(nullptr) {
- }
- bool does_need_codegen() const;
+struct FunctionBodyCode {
+ CodeBlob* code = nullptr;
void set_code(CodeBlob* code);
};
-struct SymValGlobVar : SymValBase {
- bool is_really_used{false}; // calculated via dfs from used functions; unused globals are not codegenerated
-
- SymValGlobVar(int val, TypeExpr* gvtype)
- : SymValBase(SymValKind::_GlobVar, val, gvtype) {
- }
- ~SymValGlobVar() override = default;
-};
-
-struct SymValConst : SymValBase {
- enum ConstKind { IntConst, SliceConst };
-
- td::RefInt256 intval;
- std::string strval;
- ConstKind kind;
-
- SymValConst(int idx, td::RefInt256 value)
- : SymValBase(SymValKind::_Const, idx, TypeExpr::new_atomic(TypeExpr::_Int)), intval(std::move(value)), kind(IntConst) {
- }
- SymValConst(int idx, std::string value)
- : SymValBase(SymValKind::_Const, idx, TypeExpr::new_atomic(TypeExpr::_Slice)), strval(std::move(value)), kind(SliceConst) {
- }
- ~SymValConst() override = default;
- td::RefInt256 get_int_value() const {
- return intval;
- }
- std::string get_str_value() const {
- return strval;
- }
- ConstKind get_kind() const {
- return kind;
- }
-};
-
-
-/*
- *
- * EXPRESSIONS
- *
- */
-
-struct Expr {
- enum ExprCls {
- _Apply,
- _VarApply,
- _GrabMutatedVars,
- _ReturnSelf,
- _MkTuple,
- _Tensor,
- _Const,
- _Var,
- _GlobFunc,
- _GlobVar,
- _Letop,
- _Hole,
- _CondExpr,
- _SliceConst,
- };
- ExprCls cls;
- int val{0};
- enum { _IsRvalue = 2, _IsLvalue = 4, _IsImmutable = 8, _IsImpure = 32 };
- int flags{0};
- SrcLocation here;
- td::RefInt256 intval;
- std::string strval;
- SymDef* sym{nullptr};
- TypeExpr* e_type{nullptr};
- std::vector<Expr*> args;
- Expr(ExprCls c, SrcLocation loc) : cls(c), here(loc) {
- }
- Expr(ExprCls c, std::vector<Expr*> _args) : cls(c), args(std::move(_args)) {
- }
- Expr(ExprCls c, std::initializer_list<Expr*> _arglist) : cls(c), args(std::move(_arglist)) {
- }
- Expr(ExprCls c, SymDef* _sym, std::initializer_list<Expr*> _arglist) : cls(c), sym(_sym), args(std::move(_arglist)) {
- }
- Expr(ExprCls c, SymDef* _sym, std::vector<Expr*> _arglist) : cls(c), sym(_sym), args(std::move(_arglist)) {
- }
- Expr(ExprCls c, sym_idx_t name_idx, std::initializer_list<Expr*> _arglist);
- ~Expr() {
- for (auto& arg_ptr : args) {
- delete arg_ptr;
- }
- }
- Expr* copy() const;
- void pb_arg(Expr* expr) {
- args.push_back(expr);
- }
- void set_val(int _val) {
- val = _val;
- }
- bool is_rvalue() const {
- return flags & _IsRvalue;
- }
- bool is_lvalue() const {
- return flags & _IsLvalue;
- }
- bool is_immutable() const {
- return flags & _IsImmutable;
- }
- bool is_mktuple() const {
- return cls == _MkTuple;
- }
- void chk_rvalue() const {
- if (!is_rvalue()) {
- fire_error_rvalue_expected();
- }
- }
- void deduce_type();
- void set_location(SrcLocation loc) {
- here = loc;
- }
- SrcLocation get_location() const {
- return here;
- }
- void define_new_vars(CodeBlob& code);
- void predefine_vars();
- std::vector<var_idx_t> pre_compile(CodeBlob& code, std::vector<std::pair<SymDef*, var_idx_t>>* lval_globs = nullptr) const;
- var_idx_t new_tmp(CodeBlob& code) const;
- std::vector<var_idx_t> new_tmp_vect(CodeBlob& code) const {
- return {new_tmp(code)};
- }
-
- GNU_ATTRIBUTE_COLD GNU_ATTRIBUTE_NORETURN
- void fire_error_rvalue_expected() const;
- GNU_ATTRIBUTE_COLD GNU_ATTRIBUTE_NORETURN
- void fire_error_lvalue_expected(const std::string& details) const;
- GNU_ATTRIBUTE_COLD GNU_ATTRIBUTE_NORETURN
- void fire_error_modifying_immutable(const std::string& details) const;
-};
-
/*
*
* GENERATE CODE
@@ -651,7 +414,6 @@ struct AsmOp {
int a, b;
bool gconst{false};
std::string op;
- td::RefInt256 origin;
struct SReg {
int idx;
SReg(int _idx) : idx(_idx) {
@@ -671,9 +433,6 @@ struct AsmOp {
AsmOp(Type _t, int _a, int _b, std::string _op) : t(_t), a(_a), b(_b), op(std::move(_op)) {
compute_gconst();
}
- AsmOp(Type _t, int _a, int _b, std::string _op, td::RefInt256 x) : t(_t), a(_a), b(_b), op(std::move(_op)), origin(x) {
- compute_gconst();
- }
void out(std::ostream& os) const;
void out_indent_nl(std::ostream& os, bool no_nl = false) const;
std::string to_string() const;
@@ -786,20 +545,20 @@ struct AsmOp {
static AsmOp BlkReverse(int a, int b);
static AsmOp make_stk2(int a, int b, const char* str, int delta);
static AsmOp make_stk3(int a, int b, int c, const char* str, int delta);
- static AsmOp IntConst(td::RefInt256 value);
+ static AsmOp IntConst(const td::RefInt256& x);
static AsmOp BoolConst(bool f);
- static AsmOp Const(std::string push_op, td::RefInt256 origin = {}) {
- return AsmOp(a_const, 0, 1, std::move(push_op), origin);
+ static AsmOp Const(std::string push_op) {
+ return AsmOp(a_const, 0, 1, std::move(push_op));
}
- static AsmOp Const(int arg, std::string push_op, td::RefInt256 origin = {});
- static AsmOp Comment(std::string comment) {
+ static AsmOp Const(int arg, const std::string& push_op);
+ static AsmOp Comment(const std::string& comment) {
return AsmOp(a_none, std::string{"// "} + comment);
}
- static AsmOp Custom(std::string custom_op) {
+ static AsmOp Custom(const std::string& custom_op) {
return AsmOp(a_custom, 255, 255, custom_op);
}
- static AsmOp Parse(std::string custom_op);
- static AsmOp Custom(std::string custom_op, int args, int retv = 1) {
+ static AsmOp Parse(const std::string& custom_op);
+ static AsmOp Custom(const std::string& custom_op, int args, int retv = 1) {
return AsmOp(a_custom, args, retv, custom_op);
}
static AsmOp Parse(std::string custom_op, int args, int retv = 1);
@@ -813,6 +572,7 @@ inline std::ostream& operator<<(std::ostream& os, const AsmOp& op) {
}
std::ostream& operator<<(std::ostream& os, AsmOp::SReg stack_reg);
+std::ostream& operator<<(std::ostream& os, TypePtr type_data);
struct AsmOpList {
std::vector<AsmOp> list_;
@@ -887,18 +647,6 @@ inline std::ostream& operator<<(std::ostream& os, const AsmOpList& op_list) {
return os;
}
-class IndentGuard {
- AsmOpList& aol_;
-
- public:
- IndentGuard(AsmOpList& aol) : aol_(aol) {
- aol.indent();
- }
- ~IndentGuard() {
- aol_.undent();
- }
-};
-
struct AsmOpCons {
std::unique_ptr<AsmOp> car;
std::unique_ptr<AsmOpCons> cdr;
@@ -1321,71 +1069,56 @@ struct Stack {
*/
typedef std::function<AsmOp(std::vector<VarDescr>&, std::vector<VarDescr>&, SrcLocation)> simple_compile_func_t;
-typedef std::function<bool(AsmOpList&, std::vector<VarDescr>&, std::vector<VarDescr>&)> compile_func_t;
inline simple_compile_func_t make_simple_compile(AsmOp op) {
return [op](std::vector<VarDescr>& out, std::vector<VarDescr>& in, SrcLocation) -> AsmOp { return op; };
}
-inline compile_func_t make_ext_compile(std::vector<AsmOp>&& ops) {
- return [ops = std::move(ops)](AsmOpList& dest, std::vector<VarDescr>& out, std::vector<VarDescr>& in)->bool {
- return dest.append(ops);
- };
-}
+struct FunctionBodyBuiltin {
+ simple_compile_func_t simple_compile;
-inline compile_func_t make_ext_compile(AsmOp op) {
- return
- [op](AsmOpList& dest, std::vector<VarDescr>& out, std::vector<VarDescr>& in) -> bool { return dest.append(op); };
-}
+ explicit FunctionBodyBuiltin(simple_compile_func_t compile)
+ : simple_compile(std::move(compile)) {}
-struct SymValAsmFunc : SymValFunc {
- simple_compile_func_t simple_compile;
- compile_func_t ext_compile;
- ~SymValAsmFunc() override = default;
- SymValAsmFunc(std::vector<SymDef*> parameters, TypeExpr* ft, std::vector<int>&& arg_order, std::vector<int>&& ret_order, int flags)
- : SymValFunc(std::move(parameters), -1, ft, flags) {
- this->arg_order = std::move(arg_order);
- this->ret_order = std::move(ret_order);
- }
- SymValAsmFunc(std::vector<SymDef*> parameters, TypeExpr* ft, simple_compile_func_t _compile, int flags)
- : SymValFunc(std::move(parameters), -1, ft, flags), simple_compile(std::move(_compile)) {
- }
- SymValAsmFunc(std::vector<SymDef*> parameters, TypeExpr* ft, simple_compile_func_t _compile, int flags,
- std::initializer_list<int> arg_order, std::initializer_list<int> ret_order)
- : SymValFunc(std::move(parameters), -1, ft, flags, arg_order, ret_order), simple_compile(std::move(_compile)) {
- }
- void set_code(std::vector<AsmOp> code);
- bool compile(AsmOpList& dest, std::vector<VarDescr>& out, std::vector<VarDescr>& in, SrcLocation where) const;
+ void compile(AsmOpList& dest, std::vector<VarDescr>& out, std::vector<VarDescr>& in, SrcLocation where) const;
+};
+
+struct FunctionBodyAsm {
+ std::vector<AsmOp> ops;
+
+ void set_code(std::vector<AsmOp>&& code);
+ void compile(AsmOpList& dest) const;
};
struct CodeBlob {
- enum { _ForbidImpure = 4 };
int var_cnt, in_var_cnt;
- TypeExpr* ret_type;
- const SymValCodeFunc* func_val;
+ const FunctionData* fun_ref;
std::string name;
SrcLocation loc;
std::vector<TmpVar> vars;
std::unique_ptr<Op> ops;
std::unique_ptr<Op>* cur_ops;
- std::vector<Op*> debug_ttt;
+#ifdef TOLK_DEBUG
+ std::vector<Op*> _vector_of_ops; // to see it in debugger instead of nested pointers
+#endif
std::stack<std::unique_ptr<Op>*> cur_ops_stack;
- int flags = 0;
bool require_callxargs = false;
- CodeBlob(std::string name, SrcLocation loc, const SymValCodeFunc* func_val, TypeExpr* ret_type)
- : var_cnt(0), in_var_cnt(0), ret_type(ret_type), func_val(func_val), name(std::move(name)), loc(loc), cur_ops(&ops) {
+ CodeBlob(std::string name, SrcLocation loc, const FunctionData* fun_ref)
+ : var_cnt(0), in_var_cnt(0), fun_ref(fun_ref), name(std::move(name)), loc(loc), cur_ops(&ops) {
}
template <typename... Args>
Op& emplace_back(Args&&... args) {
Op& res = *(*cur_ops = std::make_unique<Op>(args...));
cur_ops = &(res.next);
- debug_ttt.push_back(&res);
+#ifdef TOLK_DEBUG
+ _vector_of_ops.push_back(&res);
+#endif
return res;
}
- bool import_params(FormalArgList arg_list);
- var_idx_t create_var(TypeExpr* var_type, var_idx_t sym_idx, SrcLocation loc);
- var_idx_t create_tmp_var(TypeExpr* var_type, SrcLocation loc) {
- return create_var(var_type, 0, loc);
+ bool import_params(FormalArgList&& arg_list);
+ var_idx_t create_var(TypePtr var_type, const LocalVarData* v_sym, SrcLocation loc);
+ var_idx_t create_tmp_var(TypePtr var_type, SrcLocation loc) {
+ return create_var(var_type, nullptr, loc);
}
int split_vars(bool strict = false);
bool compute_used_code_vars();
@@ -1406,16 +1139,17 @@ struct CodeBlob {
close_blk(location);
pop_cur();
}
- void simplify_var_types();
void prune_unreachable_code();
void fwd_analyze();
void mark_noreturn();
void generate_code(AsmOpList& out_list, int mode = 0);
void generate_code(std::ostream& os, int mode = 0, int indent = 0);
- void on_var_modification(var_idx_t idx, SrcLocation here) const {
- for (auto& f : vars.at(idx).on_modification) {
- f(here);
+ void on_var_modification(const std::vector<var_idx_t>& left_lval_indices, SrcLocation here) const {
+ for (var_idx_t ir_idx : left_lval_indices) {
+ for (auto& f : vars.at(ir_idx).on_modification) {
+ f(here);
+ }
}
}
};
diff --git a/tolk/type-expr.h b/tolk/type-expr.h
deleted file mode 100644
index 21a35a8e3..000000000
--- a/tolk/type-expr.h
+++ /dev/null
@@ -1,131 +0,0 @@
-#pragma once
-
-#include <vector>
-#include <iostream>
-
-namespace tolk {
-
-struct TypeExpr {
- enum Kind { te_Unknown, te_Var, te_Indirect, te_Atomic, te_Tensor, te_Tuple, te_Map, te_ForAll };
- enum AtomicType { _Int, _Cell, _Slice, _Builder, _Continutaion, _Tuple };
- Kind constr;
- int value;
- int minw, maxw;
- static constexpr int w_inf = 1023;
- std::vector<TypeExpr*> args;
- bool was_forall_var = false;
-
- explicit TypeExpr(Kind _constr, int _val = 0) : constr(_constr), value(_val), minw(0), maxw(w_inf) {
- }
- TypeExpr(Kind _constr, int _val, int width) : constr(_constr), value(_val), minw(width), maxw(width) {
- }
- TypeExpr(Kind _constr, std::vector<TypeExpr*> list)
- : constr(_constr), value((int)list.size()), args(std::move(list)) {
- compute_width();
- }
- TypeExpr(Kind _constr, std::initializer_list<TypeExpr*> list)
- : constr(_constr), value((int)list.size()), args(std::move(list)) {
- compute_width();
- }
- TypeExpr(Kind _constr, TypeExpr* elem0) : constr(_constr), value(1), args{elem0} {
- compute_width();
- }
- TypeExpr(Kind _constr, TypeExpr* elem0, std::vector<TypeExpr*> list)
- : constr(_constr), value((int)list.size() + 1), args{elem0} {
- args.insert(args.end(), list.begin(), list.end());
- compute_width();
- }
- TypeExpr(Kind _constr, TypeExpr* elem0, std::initializer_list<TypeExpr*> list)
- : constr(_constr), value((int)list.size() + 1), args{elem0} {
- args.insert(args.end(), list.begin(), list.end());
- compute_width();
- }
-
- bool is_atomic() const {
- return constr == te_Atomic;
- }
- bool is_atomic(int v) const {
- return constr == te_Atomic && value == v;
- }
- bool is_int() const {
- return is_atomic(_Int);
- }
- bool is_var() const {
- return constr == te_Var;
- }
- bool is_map() const {
- return constr == te_Map;
- }
- bool is_tuple() const {
- return constr == te_Tuple;
- }
- bool has_fixed_width() const {
- return minw == maxw;
- }
- int get_width() const {
- return has_fixed_width() ? minw : -1;
- }
- void compute_width();
- bool recompute_width();
- void show_width(std::ostream& os);
- std::ostream& print(std::ostream& os, int prio = 0) const;
- void replace_with(TypeExpr* te2);
- int extract_components(std::vector<TypeExpr*>& comp_list);
- bool equals_to(const TypeExpr* rhs) const;
- bool has_unknown_inside() const;
- static int holes, type_vars;
- static TypeExpr* new_hole() {
- return new TypeExpr{te_Unknown, ++holes};
- }
- static TypeExpr* new_hole(int width) {
- return new TypeExpr{te_Unknown, ++holes, width};
- }
- static TypeExpr* new_unit() {
- return new TypeExpr{te_Tensor, 0, 0};
- }
- static TypeExpr* new_atomic(int value) {
- return new TypeExpr{te_Atomic, value, 1};
- }
- static TypeExpr* new_map(TypeExpr* from, TypeExpr* to);
- static TypeExpr* new_func() {
- return new_map(new_hole(), new_hole());
- }
- static TypeExpr* new_tensor(std::vector<TypeExpr*> list, bool red = true) {
- return red && list.size() == 1 ? list[0] : new TypeExpr{te_Tensor, std::move(list)};
- }
- static TypeExpr* new_tensor(std::initializer_list<TypeExpr*> list) {
- return new TypeExpr{te_Tensor, std::move(list)};
- }
- static TypeExpr* new_tensor(TypeExpr* te1, TypeExpr* te2) {
- return new_tensor({te1, te2});
- }
- static TypeExpr* new_tensor(TypeExpr* te1, TypeExpr* te2, TypeExpr* te3) {
- return new_tensor({te1, te2, te3});
- }
- static TypeExpr* new_tuple(TypeExpr* arg0) {
- return new TypeExpr{te_Tuple, arg0};
- }
- static TypeExpr* new_tuple(std::vector<TypeExpr*> list, bool red = false) {
- return new_tuple(new_tensor(std::move(list), red));
- }
- static TypeExpr* new_tuple(std::initializer_list<TypeExpr*> list) {
- return new_tuple(new_tensor(list));
- }
- static TypeExpr* new_var() {
- return new TypeExpr{te_Var, --type_vars, 1};
- }
- static TypeExpr* new_var(int idx) {
- return new TypeExpr{te_Var, idx, 1};
- }
- static TypeExpr* new_forall(std::vector<TypeExpr*> list, TypeExpr* body) {
- return new TypeExpr{te_ForAll, body, std::move(list)};
- }
-
- static bool remove_indirect(TypeExpr*& te, TypeExpr* forbidden = nullptr);
- static std::vector<TypeExpr*> remove_forall(TypeExpr*& te);
- static bool remove_forall_in(TypeExpr*& te, TypeExpr* te2, const std::vector<TypeExpr*>& new_vars);
-};
-
-std::ostream& operator<<(std::ostream& os, TypeExpr* type_expr);
-
-} // namespace tolk
diff --git a/tolk/type-system.cpp b/tolk/type-system.cpp
new file mode 100644
index 000000000..b21bd0eeb
--- /dev/null
+++ b/tolk/type-system.cpp
@@ -0,0 +1,702 @@
+/*
+ This file is part of TON Blockchain Library.
+
+ TON Blockchain Library is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Lesser General Public License as published by
+ the Free Software Foundation, either version 2 of the License, or
+ (at your option) any later version.
+
+ TON Blockchain Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public License
+ along with TON Blockchain Library. If not, see <http://www.gnu.org/licenses/>.
+*/
+#include "type-system.h"
+#include "lexer.h"
+#include "platform-utils.h"
+#include "compiler-state.h"
+#include <unordered_map>
+
+namespace tolk {
+
+/*
+ * This class stores a big hashtable [hash => TypeData]
+ * Every non-trivial TypeData*::create() method at first looks here, and allocates an object only if not found.
+ * That's why all allocated TypeData objects are unique, storing unique type_id.
+ */
+class TypeDataTypeIdCalculation {
+ uint64_t cur_hash;
+ int children_flags_mask = 0;
+
+ static std::unordered_map<uint64_t, TypePtr> all_unique_occurred_types;
+
+public:
+ explicit TypeDataTypeIdCalculation(uint64_t initial_arbitrary_unique_number)
+ : cur_hash(initial_arbitrary_unique_number) {}
+
+ void feed_hash(uint64_t val) {
+ cur_hash = cur_hash * 56235515617499ULL + val;
+ }
+
+ void feed_string(const std::string& s) {
+ feed_hash(std::hash<std::string>{}(s));
+ }
+
+ void feed_child(TypePtr inner) {
+ feed_hash(inner->type_id);
+ children_flags_mask |= inner->flags;
+ }
+
+ uint64_t type_id() const {
+ return cur_hash;
+ }
+
+ int children_flags() const {
+ return children_flags_mask;
+ }
+
+ GNU_ATTRIBUTE_FLATTEN
+ TypePtr get_existing() const {
+ auto it = all_unique_occurred_types.find(cur_hash);
+ return it != all_unique_occurred_types.end() ? it->second : nullptr;
+ }
+
+ GNU_ATTRIBUTE_NOINLINE
+ TypePtr register_unique(TypePtr newly_created) const {
+#ifdef TOLK_DEBUG
+ assert(newly_created->type_id == cur_hash);
+#endif
+ all_unique_occurred_types[cur_hash] = newly_created;
+ return newly_created;
+ }
+};
+
+std::unordered_map<uint64_t, TypePtr> TypeDataTypeIdCalculation::all_unique_occurred_types;
+TypePtr TypeDataInt::singleton;
+TypePtr TypeDataBool::singleton;
+TypePtr TypeDataCell::singleton;
+TypePtr TypeDataSlice::singleton;
+TypePtr TypeDataBuilder::singleton;
+TypePtr TypeDataTuple::singleton;
+TypePtr TypeDataContinuation::singleton;
+TypePtr TypeDataNullLiteral::singleton;
+TypePtr TypeDataUnknown::singleton;
+TypePtr TypeDataVoid::singleton;
+
+void type_system_init() {
+ TypeDataInt::singleton = new TypeDataInt;
+ TypeDataBool::singleton = new TypeDataBool;
+ TypeDataCell::singleton = new TypeDataCell;
+ TypeDataSlice::singleton = new TypeDataSlice;
+ TypeDataBuilder::singleton = new TypeDataBuilder;
+ TypeDataTuple::singleton = new TypeDataTuple;
+ TypeDataContinuation::singleton = new TypeDataContinuation;
+ TypeDataNullLiteral::singleton = new TypeDataNullLiteral;
+ TypeDataUnknown::singleton = new TypeDataUnknown;
+ TypeDataVoid::singleton = new TypeDataVoid;
+}
+
+
+// --------------------------------------------
+// create()
+//
+// all constructors of TypeData classes are private, only TypeData*::create() is allowed
+// each non-trivial create() method calculates hash (type_id)
+// and creates an object only if it isn't found in a global hashtable
+//
+
+TypePtr TypeDataFunCallable::create(std::vector<TypePtr>&& params_types, TypePtr return_type) {
+ TypeDataTypeIdCalculation hash(3184039965511020991ULL);
+ for (TypePtr param : params_types) {
+ hash.feed_child(param);
+ hash.feed_hash(767721);
+ }
+ hash.feed_child(return_type);
+ hash.feed_hash(767722);
+
+ if (TypePtr existing = hash.get_existing()) {
+ return existing;
+ }
+ return hash.register_unique(new TypeDataFunCallable(hash.type_id(), hash.children_flags(), std::move(params_types), return_type));
+}
+
+TypePtr TypeDataGenericT::create(std::string&& nameT) {
+ TypeDataTypeIdCalculation hash(9145033724911680012ULL);
+ hash.feed_string(nameT);
+
+ if (TypePtr existing = hash.get_existing()) {
+ return existing;
+ }
+ return hash.register_unique(new TypeDataGenericT(hash.type_id(), std::move(nameT)));
+}
+
+TypePtr TypeDataTensor::create(std::vector<TypePtr>&& items) {
+ TypeDataTypeIdCalculation hash(3159238551239480381ULL);
+ for (TypePtr item : items) {
+ hash.feed_child(item);
+ hash.feed_hash(819613);
+ }
+
+ if (TypePtr existing = hash.get_existing()) {
+ return existing;
+ }
+ return hash.register_unique(new TypeDataTensor(hash.type_id(), hash.children_flags(), std::move(items)));
+}
+
+TypePtr TypeDataTypedTuple::create(std::vector<TypePtr>&& items) {
+ TypeDataTypeIdCalculation hash(9189266157349499320ULL);
+ for (TypePtr item : items) {
+ hash.feed_child(item);
+ hash.feed_hash(735911);
+ }
+
+ if (TypePtr existing = hash.get_existing()) {
+ return existing;
+ }
+ return hash.register_unique(new TypeDataTypedTuple(hash.type_id(), hash.children_flags(), std::move(items)));
+}
+
+TypePtr TypeDataUnresolved::create(std::string&& text, SrcLocation loc) {
+ TypeDataTypeIdCalculation hash(3680147223540048162ULL);
+ hash.feed_string(text);
+ // hash.feed_hash(*reinterpret_cast<uint64_t*>(&loc));
+
+ if (TypePtr existing = hash.get_existing()) {
+ return existing;
+ }
+ return hash.register_unique(new TypeDataUnresolved(hash.type_id(), std::move(text), loc));
+}
+
+
+// --------------------------------------------
+// as_human_readable()
+//
+// is used only for error messages and debugging, therefore no optimizations for simplicity
+// only non-trivial implementations are here; trivial are defined in .h file
+//
+
+std::string TypeDataFunCallable::as_human_readable() const {
+ std::string result = "(";
+ for (TypePtr param : params_types) {
+ if (result.size() > 1) {
+ result += ", ";
+ }
+ result += param->as_human_readable();
+ }
+ result += ") -> ";
+ result += return_type->as_human_readable();
+ return result;
+}
+
+std::string TypeDataTensor::as_human_readable() const {
+ std::string result = "(";
+ for (TypePtr item : items) {
+ if (result.size() > 1) {
+ result += ", ";
+ }
+ result += item->as_human_readable();
+ }
+ result += ')';
+ return result;
+}
+
+std::string TypeDataTypedTuple::as_human_readable() const {
+ std::string result = "[";
+ for (TypePtr item : items) {
+ if (result.size() > 1) {
+ result += ", ";
+ }
+ result += item->as_human_readable();
+ }
+ result += ']';
+ return result;
+}
+
+
+// --------------------------------------------
+// traverse()
+//
+// invokes a callback for TypeData itself and all its children
+// only non-trivial implementations are here; by default (no children), `callback(this)` is executed
+//
+
+void TypeDataFunCallable::traverse(const TraverserCallbackT& callback) const {
+ callback(this);
+ for (TypePtr param : params_types) {
+ param->traverse(callback);
+ }
+ return_type->traverse(callback);
+}
+
+void TypeDataTensor::traverse(const TraverserCallbackT& callback) const {
+ callback(this);
+ for (TypePtr item : items) {
+ item->traverse(callback);
+ }
+}
+
+void TypeDataTypedTuple::traverse(const TraverserCallbackT& callback) const {
+ callback(this);
+ for (TypePtr item : items) {
+ item->traverse(callback);
+ }
+}
+
+
+// --------------------------------------------
+// replace_children_custom()
+//
+// returns new TypeData with children replaced by a custom callback
+// used to replace generic T on generics expansion — to convert `f<T>` to `f<int>`
+// only non-trivial implementations are here; by default (no children), `return callback(this)` is executed
+//
+
+TypePtr TypeDataFunCallable::replace_children_custom(const ReplacerCallbackT& callback) const {
+ std::vector<TypePtr> mapped;
+ mapped.reserve(params_types.size());
+ for (TypePtr param : params_types) {
+ mapped.push_back(param->replace_children_custom(callback));
+ }
+ return callback(create(std::move(mapped), return_type->replace_children_custom(callback)));
+}
+
+TypePtr TypeDataTensor::replace_children_custom(const ReplacerCallbackT& callback) const {
+ std::vector<TypePtr> mapped;
+ mapped.reserve(items.size());
+ for (TypePtr item : items) {
+ mapped.push_back(item->replace_children_custom(callback));
+ }
+ return callback(create(std::move(mapped)));
+}
+
+TypePtr TypeDataTypedTuple::replace_children_custom(const ReplacerCallbackT& callback) const {
+ std::vector<TypePtr> mapped;
+ mapped.reserve(items.size());
+ for (TypePtr item : items) {
+ mapped.push_back(item->replace_children_custom(callback));
+ }
+ return callback(create(std::move(mapped)));
+}
+
+
+// --------------------------------------------
+// calc_width_on_stack()
+//
+// returns the number of stack slots occupied by a variable of this type
+// only non-trivial implementations are here; by default (most types) occupy 1 stack slot
+//
+
+int TypeDataGenericT::calc_width_on_stack() const {
+ // this function is invoked only in functions with generics already instantiated
+ assert(false);
+ return -999999;
+}
+
+int TypeDataTensor::calc_width_on_stack() const {
+ int sum = 0;
+ for (TypePtr item : items) {
+ sum += item->calc_width_on_stack();
+ }
+ return sum;
+}
+
+int TypeDataUnresolved::calc_width_on_stack() const {
+ // since early pipeline stages, no unresolved types left
+ assert(false);
+ return -999999;
+}
+
+int TypeDataVoid::calc_width_on_stack() const {
+ return 0;
+}
+
+
+// --------------------------------------------
+// can_rhs_be_assigned()
+//
+// on `var lhs: <lhs_type> = rhs`, having inferred rhs_type, check that it can be assigned without any casts
+// the same goes for passing arguments, returning values, etc. — where the "receiver" (lhs) checks "applier" (rhs)
+// for now, `null` can be assigned to any TVM primitive, be later we'll have T? types and null safety
+//
+
+bool TypeDataInt::can_rhs_be_assigned(TypePtr rhs) const {
+ if (rhs == this) {
+ return true;
+ }
+ if (rhs == TypeDataNullLiteral::create()) {
+ return true;
+ }
+ return false;
+}
+
+bool TypeDataBool::can_rhs_be_assigned(TypePtr rhs) const {
+ if (rhs == this) {
+ return true;
+ }
+ if (rhs == TypeDataNullLiteral::create()) {
+ return true;
+ }
+ return false;
+}
+
+bool TypeDataCell::can_rhs_be_assigned(TypePtr rhs) const {
+ if (rhs == this) {
+ return true;
+ }
+ if (rhs == TypeDataNullLiteral::create()) {
+ return true;
+ }
+ return false;
+}
+
+bool TypeDataSlice::can_rhs_be_assigned(TypePtr rhs) const {
+ if (rhs == this) {
+ return true;
+ }
+ if (rhs == TypeDataNullLiteral::create()) {
+ return true;
+ }
+ return false;
+}
+
+bool TypeDataBuilder::can_rhs_be_assigned(TypePtr rhs) const {
+ if (rhs == this) {
+ return true;
+ }
+ if (rhs == TypeDataNullLiteral::create()) {
+ return true;
+ }
+ return false;
+}
+
+bool TypeDataTuple::can_rhs_be_assigned(TypePtr rhs) const {
+ if (rhs == this) {
+ return true;
+ }
+ if (rhs == TypeDataNullLiteral::create()) {
+ return true;
+ }
+ return false;
+}
+
+bool TypeDataContinuation::can_rhs_be_assigned(TypePtr rhs) const {
+ if (rhs == this) {
+ return true;
+ }
+ if (rhs == TypeDataNullLiteral::create()) {
+ return true;
+ }
+ return false;
+}
+
+bool TypeDataNullLiteral::can_rhs_be_assigned(TypePtr rhs) const {
+ return rhs == this;
+}
+
+bool TypeDataFunCallable::can_rhs_be_assigned(TypePtr rhs) const {
+ return rhs == this;
+}
+
+bool TypeDataGenericT::can_rhs_be_assigned(TypePtr rhs) const {
+ assert(false);
+ return false;
+}
+
+bool TypeDataTensor::can_rhs_be_assigned(TypePtr rhs) const {
+ if (const auto* as_tensor = rhs->try_as<TypeDataTensor>(); as_tensor && as_tensor->size() == size()) {
+ for (int i = 0; i < size(); ++i) {
+ if (!items[i]->can_rhs_be_assigned(as_tensor->items[i])) {
+ return false;
+ }
+ }
+ return true;
+ }
+ // note, that tensors can not accept null
+ return false;
+}
+
+bool TypeDataTypedTuple::can_rhs_be_assigned(TypePtr rhs) const {
+ if (const auto* as_tuple = rhs->try_as<TypeDataTypedTuple>(); as_tuple && as_tuple->size() == size()) {
+ for (int i = 0; i < size(); ++i) {
+ if (!items[i]->can_rhs_be_assigned(as_tuple->items[i])) {
+ return false;
+ }
+ }
+ return true;
+ }
+ if (rhs == TypeDataNullLiteral::create()) {
+ return true;
+ }
+ return false;
+}
+
+bool TypeDataUnknown::can_rhs_be_assigned(TypePtr rhs) const {
+ return true;
+}
+
+bool TypeDataUnresolved::can_rhs_be_assigned(TypePtr rhs) const {
+ assert(false);
+ return false;
+}
+
+bool TypeDataVoid::can_rhs_be_assigned(TypePtr rhs) const {
+ return rhs == this;
+}
+
+
+// --------------------------------------------
+// can_be_casted_with_as_operator()
+//
+// on `expr as <cast_to>`, check whether casting is applicable
+// note, that it's not auto-casts `var lhs: <lhs_type> = rhs`, it's an expression `rhs as <cast_to>`
+//
+
+bool TypeDataInt::can_be_casted_with_as_operator(TypePtr cast_to) const {
+ return cast_to == this;
+}
+
+bool TypeDataBool::can_be_casted_with_as_operator(TypePtr cast_to) const {
+ return cast_to == this || cast_to == TypeDataInt::create();
+}
+
+bool TypeDataCell::can_be_casted_with_as_operator(TypePtr cast_to) const {
+ return cast_to == this;
+}
+
+bool TypeDataSlice::can_be_casted_with_as_operator(TypePtr cast_to) const {
+ return cast_to == this;
+}
+
+bool TypeDataBuilder::can_be_casted_with_as_operator(TypePtr cast_to) const {
+ return cast_to == this;
+}
+
+bool TypeDataTuple::can_be_casted_with_as_operator(TypePtr cast_to) const {
+ return cast_to == this;
+}
+
+bool TypeDataContinuation::can_be_casted_with_as_operator(TypePtr cast_to) const {
+ return cast_to == this;
+}
+
+bool TypeDataNullLiteral::can_be_casted_with_as_operator(TypePtr cast_to) const {
+ return cast_to == this
+ || cast_to == TypeDataInt::create() || cast_to == TypeDataBool::create() || cast_to == TypeDataCell::create() || cast_to == TypeDataSlice::create()
+ || cast_to == TypeDataBuilder::create() || cast_to == TypeDataContinuation::create() || cast_to == TypeDataTuple::create()
+ || cast_to->try_as<TypeDataTypedTuple>();
+}
+
+bool TypeDataFunCallable::can_be_casted_with_as_operator(TypePtr cast_to) const {
+ return this == cast_to;
+}
+
+bool TypeDataGenericT::can_be_casted_with_as_operator(TypePtr cast_to) const {
+ return true;
+}
+
+bool TypeDataTensor::can_be_casted_with_as_operator(TypePtr cast_to) const {
+ if (const auto* to_tensor = cast_to->try_as<TypeDataTensor>(); to_tensor && to_tensor->size() == size()) {
+ for (int i = 0; i < size(); ++i) {
+ if (!items[i]->can_be_casted_with_as_operator(to_tensor->items[i])) {
+ return false;
+ }
+ }
+ return true;
+ }
+ return false;
+}
+
+bool TypeDataTypedTuple::can_be_casted_with_as_operator(TypePtr cast_to) const {
+ if (const auto* to_tuple = cast_to->try_as<TypeDataTypedTuple>(); to_tuple && to_tuple->size() == size()) {
+ for (int i = 0; i < size(); ++i) {
+ if (!items[i]->can_be_casted_with_as_operator(to_tuple->items[i])) {
+ return false;
+ }
+ }
+ return true;
+ }
+ return false;
+}
+
+bool TypeDataUnknown::can_be_casted_with_as_operator(TypePtr cast_to) const {
+ // 'unknown' can be cast to any type
+ // (though it's not valid for exception arguments when casting them to non-1 stack width,
+ // but to ensure it, we need a special type "unknown TVM primitive", which is overwhelming I think)
+ return true;
+}
+
+bool TypeDataUnresolved::can_be_casted_with_as_operator(TypePtr cast_to) const {
+ return false;
+}
+
+bool TypeDataVoid::can_be_casted_with_as_operator(TypePtr cast_to) const {
+ return cast_to == this;
+}
+
+
+// --------------------------------------------
+// extract_components()
+//
+// used in code generation (transforming Ops to other Ops)
+// to be removed in the future
+//
+
+void TypeDataGenericT::extract_components(std::vector<TypePtr>& comp_types) const {
+ assert(false);
+}
+
+void TypeDataTensor::extract_components(std::vector<TypePtr>& comp_types) const {
+ for (TypePtr item : items) {
+ item->extract_components(comp_types);
+ }
+}
+
+void TypeDataUnresolved::extract_components(std::vector<TypePtr>& comp_types) const {
+ assert(false);
+}
+
+void TypeDataVoid::extract_components(std::vector<TypePtr>& comp_types) const {
+}
+
+
+// --------------------------------------------
+// parsing type from tokens
+//
+// here we implement parsing types (mostly after colon) to TypeData
+// example: `var v: int` is TypeDataInt
+// example: `var v: (builder, [cell])` is TypeDataTensor(TypeDataBuilder, TypeDataTypedTuple(TypeDataCell))
+// example: `fun f(): ()` is TypeDataTensor() (an empty one)
+//
+// note, that unrecognized type names (MyEnum, MyStruct, T) are parsed as TypeDataUnresolved,
+// and later, when all files are parsed and all symbols registered, such identifiers are resolved
+// example: `fun f<T>(v: T)` at first v is TypeDataUnresolved("T"), later becomes TypeDataGenericT
+// see finalize_type_data()
+//
+// note, that `self` does not name a type, it can appear only as a return value of a function (parsed specially)
+// when `self` appears as a type, it's parsed as TypeDataUnresolved, and later an error is emitted
+//
+
+static TypePtr parse_type_expression(Lexer& lex);
+
+std::vector<TypePtr> parse_nested_type_list(Lexer& lex, TokenType tok_op, const char* s_op, TokenType tok_cl, const char* s_cl) {
+ lex.expect(tok_op, s_op);
+ std::vector<TypePtr> sub_types;
+ while (true) {
+ if (lex.tok() == tok_cl) { // empty lists allowed
+ lex.next();
+ break;
+ }
+
+ sub_types.emplace_back(parse_type_expression(lex));
+ if (lex.tok() == tok_comma) {
+ lex.next();
+ } else if (lex.tok() != tok_cl) {
+ lex.unexpected(s_cl);
+ }
+ }
+ return sub_types;
+}
+
+std::vector<TypePtr> parse_nested_type_list_in_parenthesis(Lexer& lex) {
+ return parse_nested_type_list(lex, tok_oppar, "`(`", tok_clpar, "`)` or `,`");
+}
+
+static TypePtr parse_simple_type(Lexer& lex) {
+ switch (lex.tok()) {
+ case tok_int:
+ lex.next();
+ return TypeDataInt::create();
+ case tok_bool:
+ lex.next();
+ return TypeDataBool::create();
+ case tok_cell:
+ lex.next();
+ return TypeDataCell::create();
+ case tok_builder:
+ lex.next();
+ return TypeDataBuilder::create();
+ case tok_slice:
+ lex.next();
+ return TypeDataSlice::create();
+ case tok_tuple:
+ lex.next();
+ return TypeDataTuple::create();
+ case tok_continuation:
+ lex.next();
+ return TypeDataContinuation::create();
+ case tok_null:
+ lex.next();
+ return TypeDataNullLiteral::create();
+ case tok_void:
+ lex.next();
+ return TypeDataVoid::create();
+ case tok_self:
+ case tok_identifier: {
+ SrcLocation loc = lex.cur_location();
+ std::string text = static_cast<std::string>(lex.cur_str());
+ lex.next();
+ return TypeDataUnresolved::create(std::move(text), loc);
+ }
+ case tok_oppar: {
+ std::vector<TypePtr> items = parse_nested_type_list_in_parenthesis(lex);
+ if (items.size() == 1) {
+ return items.front();
+ }
+ return TypeDataTensor::create(std::move(items));
+ }
+ case tok_opbracket: {
+ std::vector<TypePtr> items = parse_nested_type_list(lex, tok_opbracket, "`[`", tok_clbracket, "`]` or `,`");
+ return TypeDataTypedTuple::create(std::move(items));
+ }
+ case tok_fun: {
+ lex.next();
+ std::vector<TypePtr> params_types = parse_nested_type_list_in_parenthesis(lex);
+ lex.expect(tok_arrow, "`->`");
+ }
+ default:
+ lex.unexpected("<type>");
+ }
+}
+
+static TypePtr parse_type_nullable(Lexer& lex) {
+ TypePtr result = parse_simple_type(lex);
+
+ if (lex.tok() == tok_question) {
+ lex.error("nullable types are not supported yet");
+ }
+
+ return result;
+}
+
+static TypePtr parse_type_expression(Lexer& lex) {
+ TypePtr result = parse_type_nullable(lex);
+
+ if (lex.tok() == tok_arrow) { // `int -> int`, `(cell, slice) -> void`
+ lex.next();
+ TypePtr return_type = parse_type_expression(lex);
+ std::vector<TypePtr> params_types = {result};
+ if (const auto* as_tensor = result->try_as<TypeDataTensor>()) {
+ params_types = as_tensor->items;
+ }
+ return TypeDataFunCallable::create(std::move(params_types), return_type);
+ }
+
+ if (lex.tok() != tok_bitwise_or) {
+ return result;
+ }
+
+ lex.error("union types are not supported yet");
+}
+
+TypePtr parse_type_from_tokens(Lexer& lex) {
+ return parse_type_expression(lex);
+}
+
+std::ostream& operator<<(std::ostream& os, TypePtr type_data) {
+ return os << (type_data ? type_data->as_human_readable() : "(nullptr-type)");
+}
+
+} // namespace tolk
diff --git a/tolk/type-system.h b/tolk/type-system.h
new file mode 100644
index 000000000..13c0e4b09
--- /dev/null
+++ b/tolk/type-system.h
@@ -0,0 +1,423 @@
+/*
+ This file is part of TON Blockchain Library.
+
+ TON Blockchain Library is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Lesser General Public License as published by
+ the Free Software Foundation, either version 2 of the License, or
+ (at your option) any later version.
+
+ TON Blockchain Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public License
+ along with TON Blockchain Library. If not, see <http://www.gnu.org/licenses/>.
+*/
+#pragma once
+
+#include "src-file.h"
+#include <cstdint>
+#include <string>
+#include <functional>
+
+namespace tolk {
+
+/*
+ * TypeData is both a user-given and an inferred type representation.
+ * `int`, `cell`, `T`, `(int, [tuple])` are instances of TypeData.
+ * Every unique TypeData is created only once, so for example TypeDataTensor::create(int, int)
+ * returns one and the same pointer always. This "uniqueness" is called type_id, calculated before creation.
+ *
+ * In Tolk code, types after colon `var v: (int, T)` are parsed to TypeData.
+ * See parse_type_from_tokens().
+ * So, AST nodes which can have declared types (local/global variables and others) store a pointer to TypeData.
+ *
+ * Type inferring also creates TypeData for inferred expressions. All AST expression nodes have inferred_type.
+ * For example, `1 + 2`, both operands are TypeDataInt, its result is also TypeDataInt.
+ * Type checking also uses TypeData. For example, `var i: slice = 1 + 2`, at first rhs (TypeDataInt) is inferred,
+ * then lhs (TypeDataSlice from declaration) is checked whether rhs can be assigned.
+ * See can_rhs_be_assigned().
+ *
+ * Note, that while initial parsing Tolk files to AST, known types (`int`, `cell`, etc.) are created as-is,
+ * but user-defined types (`T`, `MyStruct`, `MyAlias`) are saved as TypeDataUnresolved.
+ * After all symbols have been registered, resolving identifiers step is executed, where particularly
+ * all TypeDataUnresolved instances are converted to a resolved type. At inferring, no unresolved remain.
+ * For instance, `fun f<T>(v: T)`, at first "T" of `v` is unresolved, and then converted to TypeDataGenericT.
+ */
+class TypeData {
+ // all unique types have unique type_id; it's used both for allocating memory once and for tagged unions
+ const uint64_t type_id;
+ // bits of flag_mask, to store often-used properties and return them without tree traversing
+ const int flags;
+
+ friend class TypeDataTypeIdCalculation;
+
+protected:
+ enum flag_mask {
+ flag_contains_unknown_inside = 1 << 1,
+ flag_contains_genericT_inside = 1 << 2,
+ flag_contains_unresolved_inside = 1 << 3,
+ };
+
+ explicit TypeData(uint64_t type_id, int flags_with_children)
+ : type_id(type_id)
+ , flags(flags_with_children) {
+ }
+
+public:
+ virtual ~TypeData() = default;
+
+ template<class Derived>
+ const Derived* try_as() const {
+ return dynamic_cast<const Derived*>(this);
+ }
+
+ uint64_t get_type_id() const { return type_id; }
+
+ bool has_unknown_inside() const { return flags & flag_contains_unknown_inside; }
+ bool has_genericT_inside() const { return flags & flag_contains_genericT_inside; }
+ bool has_unresolved_inside() const { return flags & flag_contains_unresolved_inside; }
+
+ using TraverserCallbackT = std::function<void(TypePtr child)>;
+ using ReplacerCallbackT = std::function<TypePtr(TypePtr child)>;
+
+ virtual std::string as_human_readable() const = 0;
+ virtual bool can_rhs_be_assigned(TypePtr rhs) const = 0;
+ virtual bool can_be_casted_with_as_operator(TypePtr cast_to) const = 0;
+
+ virtual void traverse(const TraverserCallbackT& callback) const {
+ callback(this);
+ }
+
+ virtual TypePtr replace_children_custom(const ReplacerCallbackT& callback) const {
+ return callback(this);
+ }
+
+ virtual int calc_width_on_stack() const {
+ return 1;
+ }
+
+ virtual void extract_components(std::vector<TypePtr>& comp_types) const {
+ comp_types.push_back(this);
+ }
+};
+
+/*
+ * `int` is TypeDataInt, representation of TVM int.
+ */
+class TypeDataInt final : public TypeData {
+ TypeDataInt() : TypeData(1ULL, 0) {}
+
+ static TypePtr singleton;
+ friend void type_system_init();
+
+public:
+ static TypePtr create() { return singleton; }
+
+ std::string as_human_readable() const override { return "int"; }
+ bool can_rhs_be_assigned(TypePtr rhs) const override;
+ bool can_be_casted_with_as_operator(TypePtr cast_to) const override;
+};
+
+/*
+ * `bool` is TypeDataBool. TVM has no bool, only integers. Under the hood, -1 is true, 0 is false.
+ * From the type system point of view, int and bool are different, not-autocastable types.
+ */
+class TypeDataBool final : public TypeData {
+ TypeDataBool() : TypeData(2ULL, 0) {}
+
+ static TypePtr singleton;
+ friend void type_system_init();
+
+public:
+ static TypePtr create() { return singleton; }
+
+ std::string as_human_readable() const override { return "bool"; }
+ bool can_rhs_be_assigned(TypePtr rhs) const override;
+ bool can_be_casted_with_as_operator(TypePtr cast_to) const override;
+};
+
+/*
+ * `cell` is TypeDataCell, representation of TVM cell.
+ */
+class TypeDataCell final : public TypeData {
+ TypeDataCell() : TypeData(3ULL, 0) {}
+
+ static TypePtr singleton;
+ friend void type_system_init();
+
+public:
+ static TypePtr create() { return singleton; }
+
+ std::string as_human_readable() const override { return "cell"; }
+ bool can_rhs_be_assigned(TypePtr rhs) const override;
+ bool can_be_casted_with_as_operator(TypePtr cast_to) const override;
+};
+
+/*
+ * `slice` is TypeDataSlice, representation of TVM slice.
+ */
+class TypeDataSlice final : public TypeData {
+ TypeDataSlice() : TypeData(4ULL, 0) {}
+
+ static TypePtr singleton;
+ friend void type_system_init();
+
+public:
+ static TypePtr create() { return singleton; }
+
+ std::string as_human_readable() const override { return "slice"; }
+ bool can_rhs_be_assigned(TypePtr rhs) const override;
+ bool can_be_casted_with_as_operator(TypePtr cast_to) const override;
+};
+
+/*
+ * `builder` is TypeDataBuilder, representation of TVM builder.
+ */
+class TypeDataBuilder final : public TypeData {
+ TypeDataBuilder() : TypeData(5ULL, 0) {}
+
+ static TypePtr singleton;
+ friend void type_system_init();
+
+public:
+ static TypePtr create() { return singleton; }
+
+ std::string as_human_readable() const override { return "builder"; }
+ bool can_rhs_be_assigned(TypePtr rhs) const override;
+ bool can_be_casted_with_as_operator(TypePtr cast_to) const override;
+};
+
+/*
+ * `tuple` is TypeDataTuple, representation of TVM tuple.
+ * Note, that it's UNTYPED tuple. It occupies 1 stack slot in TVM. Its elements are any TVM values at runtime,
+ * so getting its element results in TypeDataUnknown (which must be assigned/cast explicitly).
+ */
+class TypeDataTuple final : public TypeData {
+ TypeDataTuple() : TypeData(6ULL, 0) {}
+
+ static TypePtr singleton;
+ friend void type_system_init();
+
+public:
+ static TypePtr create() { return singleton; }
+
+ std::string as_human_readable() const override { return "tuple"; }
+ bool can_rhs_be_assigned(TypePtr rhs) const override;
+ bool can_be_casted_with_as_operator(TypePtr cast_to) const override;
+};
+
+/*
+ * `continuation` is TypeDataContinuation, representation of TVM continuation.
+ * It's like "untyped callable", not compatible with other types.
+ */
+class TypeDataContinuation final : public TypeData {
+ TypeDataContinuation() : TypeData(7ULL, 0) {}
+
+ static TypePtr singleton;
+ friend void type_system_init();
+
+public:
+ static TypePtr create() { return singleton; }
+
+ std::string as_human_readable() const override { return "continuation"; }
+ bool can_rhs_be_assigned(TypePtr rhs) const override;
+ bool can_be_casted_with_as_operator(TypePtr cast_to) const override;
+};
+
+/*
+ * `null` has TypeDataNullLiteral type.
+ * Currently, it can be assigned to int/slice/etc., but later Tolk will have T? types and null safety.
+ * Note, that `var i = null`, though valid (i would be constant null), fires an "always-null" compilation error
+ * (it's much better for user to see an error here than when he passes this variable somewhere).
+ */
+class TypeDataNullLiteral final : public TypeData {
+ TypeDataNullLiteral() : TypeData(8ULL, 0) {}
+
+ static TypePtr singleton;
+ friend void type_system_init();
+
+public:
+ static TypePtr create() { return singleton; }
+
+ std::string as_human_readable() const override { return "null"; }
+ bool can_rhs_be_assigned(TypePtr rhs) const override;
+ bool can_be_casted_with_as_operator(TypePtr cast_to) const override;
+};
+
+/*
+ * `fun(int, int) -> void` is TypeDataFunCallable, think of is as a typed continuation.
+ * A type of function `fun f(x: int) { return x; }` is actually `fun(int) -> int`.
+ * So, when assigning it to a variable `var cb = f`, this variable also has this type.
+ */
+class TypeDataFunCallable final : public TypeData {
+ TypeDataFunCallable(uint64_t type_id, int children_flags, std::vector<TypePtr>&& params_types, TypePtr return_type)
+ : TypeData(type_id, children_flags)
+ , params_types(std::move(params_types))
+ , return_type(return_type) {}
+
+public:
+ const std::vector<TypePtr> params_types;
+ const TypePtr return_type;
+
+ static TypePtr create(std::vector<TypePtr>&& params_types, TypePtr return_type);
+
+ int params_size() const { return static_cast<int>(params_types.size()); }
+
+ std::string as_human_readable() const override;
+ bool can_rhs_be_assigned(TypePtr rhs) const override;
+ bool can_be_casted_with_as_operator(TypePtr cast_to) const override;
+ void traverse(const TraverserCallbackT& callback) const override;
+ TypePtr replace_children_custom(const ReplacerCallbackT& callback) const override;
+};
+
+/*
+ * `T` inside generic functions is TypeDataGenericT.
+ * Example: `fun f<X,Y>(a: X, b: Y): [X, Y]` (here X and Y are).
+ * On instantiation like `f(1,"")`, a new function `f<int,slice>` is created with type `fun(int,slice)->[int,slice]`.
+ */
+class TypeDataGenericT final : public TypeData {
+ TypeDataGenericT(uint64_t type_id, std::string&& nameT)
+ : TypeData(type_id, flag_contains_genericT_inside)
+ , nameT(std::move(nameT)) {}
+
+public:
+ const std::string nameT;
+
+ static TypePtr create(std::string&& nameT);
+
+ std::string as_human_readable() const override { return nameT; }
+ bool can_rhs_be_assigned(TypePtr rhs) const override;
+ bool can_be_casted_with_as_operator(TypePtr cast_to) const override;
+ int calc_width_on_stack() const override;
+ void extract_components(std::vector<TypePtr>& comp_types) const override;
+};
+
+/*
+ * `(int, slice)` is TypeDataTensor of 2 elements. Tensor of N elements occupies N stack slots.
+ * Of course, there may be nested tensors, like `(int, (int, slice), cell)`.
+ * Arguments, variables, globals, return values, etc. can be tensors.
+ * A tensor can be empty.
+ */
+class TypeDataTensor final : public TypeData {
+ TypeDataTensor(uint64_t type_id, int children_flags, std::vector<TypePtr>&& items)
+ : TypeData(type_id, children_flags)
+ , items(std::move(items)) {}
+
+public:
+ const std::vector<TypePtr> items;
+
+ static TypePtr create(std::vector<TypePtr>&& items);
+
+ int size() const { return static_cast<int>(items.size()); }
+
+ std::string as_human_readable() const override;
+ bool can_rhs_be_assigned(TypePtr rhs) const override;
+ bool can_be_casted_with_as_operator(TypePtr cast_to) const override;
+ void traverse(const TraverserCallbackT& callback) const override;
+ TypePtr replace_children_custom(const ReplacerCallbackT& callback) const override;
+ int calc_width_on_stack() const override;
+ void extract_components(std::vector<TypePtr>& comp_types) const override;
+};
+
+/*
+ * `[int, slice]` is TypeDataTypedTuple, a TVM 'tuple' under the hood, contained in 1 stack slot.
+ * Unlike TypeDataTuple (untyped tuples), it has a predefined inner structure and can be assigned as
+ * `var [i, cs] = [0, ""]` (where a and b become two separate variables on a stack, int and slice).
+ */
+class TypeDataTypedTuple final : public TypeData {
+ TypeDataTypedTuple(uint64_t type_id, int children_flags, std::vector<TypePtr>&& items)
+ : TypeData(type_id, children_flags)
+ , items(std::move(items)) {}
+
+public:
+ const std::vector<TypePtr> items;
+
+ static TypePtr create(std::vector<TypePtr>&& items);
+
+ int size() const { return static_cast<int>(items.size()); }
+
+ std::string as_human_readable() const override;
+ bool can_rhs_be_assigned(TypePtr rhs) const override;
+ bool can_be_casted_with_as_operator(TypePtr cast_to) const override;
+ void traverse(const TraverserCallbackT& callback) const override;
+ TypePtr replace_children_custom(const ReplacerCallbackT& callback) const override;
+};
+
+/*
+ * `unknown` is a special type, which can appear in corner cases.
+ * The type of exception argument (which can hold any TVM value at runtime) is unknown.
+ * The type of `_` used as rvalue is unknown.
+ * The only thing available to do with unknown is to cast it: `catch (excNo, arg) { var i = arg as int; }`
+ */
+class TypeDataUnknown final : public TypeData {
+ TypeDataUnknown() : TypeData(20ULL, flag_contains_unknown_inside) {}
+
+ static TypePtr singleton;
+ friend void type_system_init();
+
+public:
+ static TypePtr create() { return singleton; }
+
+ std::string as_human_readable() const override { return "unknown"; }
+ bool can_rhs_be_assigned(TypePtr rhs) const override;
+ bool can_be_casted_with_as_operator(TypePtr cast_to) const override;
+};
+
+/*
+ * "Unresolved" is not actually a type — it's an intermediate state between parsing and resolving.
+ * At parsing to AST, unrecognized type names (MyEnum, MyStruct, T) are parsed as TypeDataUnresolved,
+ * and after all source files parsed and global symbols registered, they are replaced by actual ones.
+ * Example: `fun f<T>(v: T)` at first v is TypeDataUnresolved("T"), later becomes TypeDataGenericT.
+ */
+class TypeDataUnresolved final : public TypeData {
+ TypeDataUnresolved(uint64_t type_id, std::string&& text, SrcLocation loc)
+ : TypeData(type_id, flag_contains_unresolved_inside)
+ , text(std::move(text))
+ , loc(loc) {}
+
+public:
+ const std::string text;
+ const SrcLocation loc;
+
+ static TypePtr create(std::string&& text, SrcLocation loc);
+
+ std::string as_human_readable() const override { return text + "*"; }
+ bool can_rhs_be_assigned(TypePtr rhs) const override;
+ bool can_be_casted_with_as_operator(TypePtr cast_to) const override;
+ int calc_width_on_stack() const override;
+ void extract_components(std::vector<TypePtr>& comp_types) const override;
+};
+
+/*
+ * `void` is TypeDataVoid.
+ * From the type system point of view, `void` functions return nothing.
+ * Empty tensor is not compatible with void, although at IR level they are similar, 0 stack slots.
+ */
+class TypeDataVoid final : public TypeData {
+ TypeDataVoid() : TypeData(10ULL, 0) {}
+
+ static TypePtr singleton;
+ friend void type_system_init();
+
+public:
+ static TypePtr create() { return singleton; }
+
+ std::string as_human_readable() const override { return "void"; }
+ bool can_rhs_be_assigned(TypePtr rhs) const override;
+ bool can_be_casted_with_as_operator(TypePtr cast_to) const override;
+ int calc_width_on_stack() const override;
+ void extract_components(std::vector<TypePtr>& comp_types) const override;
+};
+
+
+// --------------------------------------------
+
+
+class Lexer;
+TypePtr parse_type_from_tokens(Lexer& lex);
+
+void type_system_init();
+
+} // namespace tolk
diff --git a/tolk/unify-types.cpp b/tolk/unify-types.cpp
deleted file mode 100644
index cee71942b..000000000
--- a/tolk/unify-types.cpp
+++ /dev/null
@@ -1,454 +0,0 @@
-/*
- This file is part of TON Blockchain Library.
-
- TON Blockchain Library is free software: you can redistribute it and/or modify
- it under the terms of the GNU Lesser General Public License as published by
- the Free Software Foundation, either version 2 of the License, or
- (at your option) any later version.
-
- TON Blockchain Library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public License
- along with TON Blockchain Library. If not, see <http://www.gnu.org/licenses/>.
-*/
-#include "tolk.h"
-
-namespace tolk {
-
-/*
- *
- * TYPE EXPRESSIONS
- *
- */
-
-int TypeExpr::holes = 0, TypeExpr::type_vars = 0; // not thread safe, but it is ok for now
-
-void TypeExpr::compute_width() {
- switch (constr) {
- case te_Atomic:
- case te_Map:
- minw = maxw = 1;
- break;
- case te_Tensor:
- minw = maxw = 0;
- for (TypeExpr* arg : args) {
- minw += arg->minw;
- maxw += arg->maxw;
- }
- if (minw > w_inf) {
- minw = w_inf;
- }
- if (maxw > w_inf) {
- maxw = w_inf;
- }
- break;
- case te_Tuple:
- minw = maxw = 1;
- for (TypeExpr* arg : args) {
- arg->compute_width();
- }
- break;
- case te_Indirect:
- minw = args[0]->minw;
- maxw = args[0]->maxw;
- break;
- default:
- minw = 0;
- maxw = w_inf;
- break;
- }
-}
-
-bool TypeExpr::recompute_width() {
- switch (constr) {
- case te_Tensor:
- case te_Indirect: {
- int min = 0, max = 0;
- for (TypeExpr* arg : args) {
- min += arg->minw;
- max += arg->maxw;
- }
- if (min > maxw || max < minw) {
- return false;
- }
- if (min > w_inf) {
- min = w_inf;
- }
- if (max > w_inf) {
- max = w_inf;
- }
- if (minw < min) {
- minw = min;
- }
- if (maxw > max) {
- maxw = max;
- }
- return true;
- }
- case te_Tuple: {
- for (TypeExpr* arg : args) {
- if (arg->minw > 1 || arg->maxw < 1 || arg->minw > arg->maxw) {
- return false;
- }
- }
- return true;
- }
- default:
- return false;
- }
-}
-
-int TypeExpr::extract_components(std::vector<TypeExpr*>& comp_list) {
- if (constr != te_Indirect && constr != te_Tensor) {
- comp_list.push_back(this);
- return 1;
- }
- int res = 0;
- for (TypeExpr* arg : args) {
- res += arg->extract_components(comp_list);
- }
- return res;
-}
-
-bool TypeExpr::equals_to(const TypeExpr *rhs) const {
- const TypeExpr *l = this;
- const TypeExpr *r = rhs;
- while (l->constr == te_Indirect)
- l = l->args[0];
- while (r->constr == te_Indirect)
- r = r->args[0];
-
- bool eq = l->constr == r->constr && l->value == r->value &&
- l->minw == r->minw && l->maxw == r->maxw &&
- l->was_forall_var == r->was_forall_var &&
- l->args.size() == r->args.size();
- if (!eq)
- return false;
-
- for (int i = 0; i < static_cast<int>(l->args.size()); ++i) {
- if (!l->args[i]->equals_to(r->args[i]))
- return false;
- }
- return true;
-}
-
-bool TypeExpr::has_unknown_inside() const {
- if (constr == te_Unknown)
- return true;
-
- for (const TypeExpr* inner : args) {
- if (inner->has_unknown_inside())
- return true;
- }
- return false;
-}
-
-TypeExpr* TypeExpr::new_map(TypeExpr* from, TypeExpr* to) {
- return new TypeExpr{te_Map, std::vector<TypeExpr*>{from, to}};
-}
-
-void TypeExpr::replace_with(TypeExpr* te2) {
- if (te2 == this) {
- return;
- }
- constr = te_Indirect;
- value = 0;
- minw = te2->minw;
- maxw = te2->maxw;
- args.clear();
- args.push_back(te2);
-}
-
-bool TypeExpr::remove_indirect(TypeExpr*& te, TypeExpr* forbidden) {
- tolk_assert(te);
- while (te->constr == te_Indirect) {
- te = te->args[0];
- }
- if (te->constr == te_Unknown) {
- return te != forbidden;
- }
- bool res = true;
- for (auto& x : te->args) {
- res &= remove_indirect(x, forbidden);
- }
- return res;
-}
-
-std::vector<TypeExpr*> TypeExpr::remove_forall(TypeExpr*& te) {
- tolk_assert(te && te->constr == te_ForAll);
- tolk_assert(te->args.size() >= 1);
- std::vector<TypeExpr*> new_vars;
- for (std::size_t i = 1; i < te->args.size(); i++) {
- new_vars.push_back(new_hole(1));
- }
- TypeExpr* te2 = te;
- // std::cerr << "removing universal quantifier in " << te << std::endl;
- te = te->args[0];
- remove_forall_in(te, te2, new_vars);
- // std::cerr << "-> " << te << std::endl;
- return new_vars;
-}
-
-bool TypeExpr::remove_forall_in(TypeExpr*& te, TypeExpr* te2, const std::vector<TypeExpr*>& new_vars) {
- tolk_assert(te);
- tolk_assert(te2 && te2->constr == te_ForAll);
- if (te->constr == te_Var) {
- for (std::size_t i = 0; i < new_vars.size(); i++) {
- if (te == te2->args[i + 1]) {
- te = new_vars[i];
- return true;
- }
- }
- return false;
- }
- if (te->constr == te_ForAll) {
- return false;
- }
- if (te->args.empty()) {
- return false;
- }
- auto te1 = new TypeExpr(*te);
- bool res = false;
- for (auto& arg : te1->args) {
- res |= remove_forall_in(arg, te2, new_vars);
- }
- if (res) {
- te = te1;
- } else {
- delete te1;
- }
- return res;
-}
-
-void TypeExpr::show_width(std::ostream& os) {
- os << minw;
- if (maxw != minw) {
- os << "..";
- if (maxw < w_inf) {
- os << maxw;
- }
- }
-}
-
-std::ostream& operator<<(std::ostream& os, TypeExpr* type_expr) {
- if (!type_expr) {
- return os << "(null-type-ptr)";
- }
- return type_expr->print(os);
-}
-
-std::ostream& TypeExpr::print(std::ostream& os, int lex_level) const {
- switch (constr) {
- case te_Unknown:
- return os << "??" << value;
- case te_Var:
- if (value >= -26 && value < 0) {
- return os << "_" << (char)(91 + value);
- } else if (value >= 0 && value < 26) {
- return os << (char)(65 + value);
- } else {
- return os << "TVAR" << value;
- }
- case te_Indirect:
- return os << args[0];
- case te_Atomic: {
- switch (value) {
- case _Int:
- return os << "int";
- case _Cell:
- return os << "cell";
- case _Slice:
- return os << "slice";
- case _Builder:
- return os << "builder";
- case _Continutaion:
- return os << "cont";
- case _Tuple:
- return os << "tuple";
- default:
- return os << "atomic-type-" << value;
- }
- }
- case te_Tensor: {
- if (lex_level > -127) {
- os << "(";
- }
- auto c = args.size();
- if (c) {
- for (const auto& x : args) {
- x->print(os);
- if (--c) {
- os << ", ";
- }
- }
- }
- if (lex_level > -127) {
- os << ")";
- }
- return os;
- }
- case te_Tuple: {
- os << "[";
- auto c = args.size();
- if (c == 1 && args[0]->constr == te_Tensor) {
- args[0]->print(os, -127);
- } else if (c) {
- for (const auto& x : args) {
- x->print(os);
- if (--c) {
- os << ", ";
- }
- }
- }
- return os << "]";
- }
- case te_Map: {
- tolk_assert(args.size() == 2);
- if (lex_level > 0) {
- os << "(";
- }
- args[0]->print(os, 1);
- os << " -> ";
- args[1]->print(os);
- if (lex_level > 0) {
- os << ")";
- }
- return os;
- }
- case te_ForAll: {
- tolk_assert(args.size() >= 1);
- if (lex_level > 0) {
- os << '(';
- }
- os << "Forall ";
- for (std::size_t i = 1; i < args.size(); i++) {
- os << (i > 1 ? ' ' : '(');
- args[i]->print(os);
- }
- os << ") ";
- args[0]->print(os);
- if (lex_level > 0) {
- os << ')';
- }
- return os;
- }
- default:
- return os << "unknown-type-expr-" << constr;
- }
-}
-
-void UnifyError::print_message(std::ostream& os) const {
- os << "cannot unify type " << te1 << " with " << te2;
- if (!msg.empty()) {
- os << ": " << msg;
- }
-}
-
-std::ostream& operator<<(std::ostream& os, const UnifyError& ue) {
- ue.print_message(os);
- return os;
-}
-
-void check_width_compat(TypeExpr* te1, TypeExpr* te2) {
- if (te1->minw > te2->maxw || te2->minw > te1->maxw) {
- std::ostringstream os{"cannot unify types of widths ", std::ios_base::ate};
- te1->show_width(os);
- os << " and ";
- te2->show_width(os);
- throw UnifyError{te1, te2, os.str()};
- }
-}
-
-void check_update_widths(TypeExpr* te1, TypeExpr* te2) {
- check_width_compat(te1, te2);
- te1->minw = te2->minw = std::max(te1->minw, te2->minw);
- te1->maxw = te2->maxw = std::min(te1->maxw, te2->maxw);
- tolk_assert(te1->minw <= te1->maxw);
-}
-
-void unify(TypeExpr*& te1, TypeExpr*& te2) {
- tolk_assert(te1 && te2);
- // std::cerr << "unify( " << te1 << " , " << te2 << " )\n";
- while (te1->constr == TypeExpr::te_Indirect) {
- te1 = te1->args[0];
- }
- while (te2->constr == TypeExpr::te_Indirect) {
- te2 = te2->args[0];
- }
- if (te1 == te2) {
- return;
- }
- if (te1->constr == TypeExpr::te_ForAll) {
- TypeExpr* te = te1;
- std::vector<TypeExpr*> new_vars = TypeExpr::remove_forall(te);
- for (TypeExpr* t : new_vars) {
- t->was_forall_var = true;
- }
- unify(te, te2);
- for (TypeExpr* t : new_vars) {
- t->was_forall_var = false;
- }
- return;
- }
- if (te2->constr == TypeExpr::te_ForAll) {
- TypeExpr* te = te2;
- std::vector<TypeExpr*> new_vars = TypeExpr::remove_forall(te);
- for (TypeExpr* t : new_vars) {
- t->was_forall_var = true;
- }
- unify(te1, te);
- for (TypeExpr* t : new_vars) {
- t->was_forall_var = false;
- }
- return;
- }
- if (te1->was_forall_var && te2->constr == TypeExpr::te_Tensor) {
- throw UnifyError{te1, te2, "cannot unify generic type and tensor"};
- }
- if (te2->was_forall_var && te1->constr == TypeExpr::te_Tensor) {
- throw UnifyError{te2, te1, "cannot unify generic type and tensor"};
- }
- if (te1->constr == TypeExpr::te_Unknown) {
- if (te2->constr == TypeExpr::te_Unknown) {
- tolk_assert(te1->value != te2->value);
- }
- if (!TypeExpr::remove_indirect(te2, te1)) {
- throw UnifyError{te1, te2, "type unification results in an infinite cyclic type"};
- }
- check_update_widths(te1, te2);
- te1->replace_with(te2);
- te1 = te2;
- return;
- }
- if (te2->constr == TypeExpr::te_Unknown) {
- if (!TypeExpr::remove_indirect(te1, te2)) {
- throw UnifyError{te2, te1, "type unification results in an infinite cyclic type"};
- }
- check_update_widths(te2, te1);
- te2->replace_with(te1);
- te2 = te1;
- return;
- }
- if (te1->constr != te2->constr || te1->value != te2->value || te1->args.size() != te2->args.size()) {
- throw UnifyError{te1, te2};
- }
- for (std::size_t i = 0; i < te1->args.size(); i++) {
- unify(te1->args[i], te2->args[i]);
- }
- if (te1->constr == TypeExpr::te_Tensor) {
- if (!te1->recompute_width()) {
- throw UnifyError{te1, te2, "type unification incompatible with known width of first type"};
- }
- if (!te2->recompute_width()) {
- throw UnifyError{te2, te1, "type unification incompatible with known width of first type"};
- }
- check_update_widths(te1, te2);
- }
- te1->replace_with(te2);
- te1 = te2;
-}
-
-} // namespace tolk