[Tolk] Union types T1 | T2 | ... and pattern matching

Union types allow a variable to hold multiple possible types.
They are key to message parsing and routing in future struct-based designs.
At the TVM level, they are tagged unions, like enums in Rust.

Pattern matching is the only way of handling union types:
> match (result) {
>     slice  => { /* result is smart-casted to slice  */ }
>     UserId => { /* result is smart-casted to UserId */ }
> }

`match` must cover all union cases (should be exhaustive).
It can also be used as an expression.
Variable declaration inside `match` is allowed.

Besides `match`, you can test a union type by `is`:
> if (v is cell) {
>     // v is smart-casted to cell

Author: tolk-vm

tolk-tester/tests/generics-1.tolk

@@ -24,6 +24,7 @@ fun test102(): (int, int, int, [int, int]) {
     var b = getTwo() as int;
     var c: int = 1 ? getTwo() : getTwo();
     var c redef = getTwo();
+    var d: int = match (1 as int|slice|builder) { int => getTwo(), slice => getTwo(), builder => getTwo() };
     var ab_tens = (0, (1, 2));
     ab_tens.0 = getTwo();
     ab_tens.1.1 = getTwo();
@@ -169,6 +170,29 @@ fun test111() {
     return (isSomeNullableNull(i1), isSomeNullableNull(i2), isSomeNullableNull<int8>(i1), isSomeNullableNull<int?>(i1));
 }
 
+@method_id(112)
+fun test112(v: int | slice?) {
+    return (eq1(v), eq4(v == null));
+}
+
+fun makeNullable<T1, T2>(a: T1 | T2): T1 | T2 | null {
+    return a;
+}
+
+@method_id(113)
+fun test113(a: int | slice) {
+    var b: int | (int, int) = match (a) {
+        int => a,
+        slice => (a.loadInt(32), -1)
+    };
+    __expect_type(makeNullable(b), "int | (int, int) | null");
+    return (
+        makeNullable(a), -100, makeNullable(b), -100, makeNullable<int, null>(9), -100, makeNullable<slice, null>(null), -100,
+        makeNullable<int, (int, int) | builder>(b), -100, makeNullable<int, (int, int, int)?>(null)
+    );
+}
+
+
 fun main(x: int): (int, [Tup2Int]) {
     __expect_type(test110, "() -> (Tensor2Int, Tensor2Int)");
 
@@ -190,12 +214,16 @@ fun main(x: int): (int, [Tup2Int]) {
 @testcase | 109 | 5 | 5 (null) (null)
 @testcase | 110 |   | 2 2 5 2
 @testcase | 111 |   | 0 0 0 0
+@testcase | 112 | 5 1 | 5 1 0
+@testcase | 112 | 0 0 | 0 0 -1
+@testcase | 113 | 5 1 | 5 1 -100 (null) 5 1 -100 9 -100 (null) -100 (null) 5 1 -100 (null) (null) (null) 0
 
 @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 eq1<MInt?>
+@fif_codegen DECLPROC eq1<int|slice|null>
 @fif_codegen DECLPROC getTwo<int>
 
 @fif_codegen_avoid DECLPROC eq1

tolk-tester/tests/intN-tests.tolk

@@ -23,13 +23,13 @@ fun autoInferUInt16Opt(x: uint16) {
     return null;
 }
 
-fun autoInferInt_v1() {
+fun inferInt_v1(): int {
     if (random()) { return 0; }
     else if (random()) { return 0 as uint16; }
     else { return 0 as int8; }
 }
 
-fun autoInferInt_v2() {
+fun inferInt_v2(): int {
     if (random()) { return 0 as uint1; }
     else if (random()) { return 0 as int123; }
     else { return 0 as int8; }
@@ -87,8 +87,8 @@ fun test3(op: int32, qid: uint64) {
 
     __expect_type(autoInferInt8, "(int8) -> int8");
     __expect_type(autoInferUInt16Opt(0), "uint16?");
-    __expect_type(autoInferInt_v1(), "int");
-    __expect_type(autoInferInt_v2(), "int");
+    __expect_type(inferInt_v1(), "int");
+    __expect_type(inferInt_v2(), "int");
 
     var amount: uint100 = 1000;
     var percent: uint8 = 50;
@@ -124,7 +124,7 @@ fun test5() {
 fun test6() {
     var x: int11 = ~(0 as int22);
     while (x) {}
-    return x ? x : 0;
+    return x ? x as int : 0;
 }
 
 fun test7() {
@@ -211,7 +211,7 @@ fun test13(x1: int?, x2: int8?, x3: int, x4: int8): (int8?, int8?, int8?, int8?,
 
 @method_id(114)
 fun test14(firstComponent: int8?): (int, int16)? {
-    return firstComponent! < 10 ? null : (firstComponent!, 2);
+    return firstComponent! < 10 ? null : (firstComponent! as int, 2 as int16);
 }
 
 fun assign0<T>(mutate v: T) { v = 0; }
@@ -232,7 +232,7 @@ fun main() {
     __expect_type(0 as coins, "coins");
     __expect_type(someN_coins as coins?, "coins?");
     __expect_type(someN_coins as int8?, "int8?");
-    __expect_type(10>3 ? 0 as uint8 : 0 as uint16, "int");
+    __expect_type(10>3 ? (0 as uint8) as uint8 | uint16 : 0 as uint16, "uint8 | uint16");
     return t;
 }
 
@@ -245,7 +245,7 @@ fun main() {
 @testcase | 110 |      | 50000000 50000100 1234000000 51000000
 @testcase | 111 |      | [ 1000000000 1000000000 1000000000 -321123456789 321123456789 1100000000 ]
 @testcase | 114 | 5    | (null) (null) 0
-@testcase | 114 | 15   | 15 2 -1
+@testcase | 114 | 15   | 15 2 130
 
 @fif_codegen DECLPROC assign0<int8>
 @fif_codegen DECLPROC assign0<uint16>

tolk-tester/tests/invalid-declaration/err-1140.tolk

@@ -0,0 +1,26 @@
+fun okWithJustInt(a: int8, b: int16): int {
+    if (a > 10) {
+        return a;
+    }
+    return b;
+}
+
+fun okWithManualUnion(a: int8, b: int16): int16 | int8 {
+    if (a > 10) {
+        return a;
+    }
+    return b;
+}
+
+fun autoInferUnionType(a: int8, b: int16) {
+    if (a > 10) {
+        return a;
+    }
+    return b;
+}
+
+/**
+@compilation_should_fail
+@stderr function `autoInferUnionType` calculated return type is `int8 | int16`; probably, it's not what you expected; declare `fun (...): <return_type>` manually
+@stderr fun autoInferUnionType
+ */

tolk-tester/tests/invalid-declaration/err-1473.tolk

@@ -0,0 +1,16 @@
+fun getIntOrSlice() { return 5 as int | slice; }
+
+fun autoInferUnionType(a: int | slice | null) {
+    var cc = match (a) {
+        int => a = getIntOrSlice(),
+        slice => return beginCell(),
+        null => return -20
+    };
+    return cc;
+}
+
+/**
+@compilation_should_fail
+@stderr function `autoInferUnionType` calculated return type is `builder | int | slice`; probably, it's not what you expected
+@stderr fun autoInferUnionType
+ */

tolk-tester/tests/invalid-semantics/err-4355.tolk

@@ -0,0 +1,21 @@
+fun increment(mutate x: int) {
+    x += 1;
+}
+
+fun cantModifyValDeclaredInMatch() {
+    match (var a = (0 + 10 + 90) as int | slice) {
+        int => increment(mutate a),
+        slice => {},
+    };
+    match (val b = (0 + 10 + 90) as int | slice) {
+        int => increment(mutate b),
+        slice => {},
+    };
+}
+
+/**
+@compilation_should_fail
+@stderr modifying immutable variable `b`
+@stderr in function `cantModifyValDeclaredInMatch`
+@stderr increment(mutate b)
+ */

tolk-tester/tests/invalid-symbol/err-2208.tolk

@@ -0,0 +1,13 @@
+fun main(x: int | slice) {
+    match (var a = x) {     // a variable declared in `match` subject exists only within a match
+        int => a + 0,
+        slice => a.loadInt(32),
+    }
+    return a;
+}
+
+/**
+@compilation_should_fail
+@stderr undefined symbol `a`
+@stderr return a;
+ */

tolk-tester/tests/invalid-symbol/err-2355.tolk

@@ -0,0 +1,12 @@
+
+fun main() {
+    match (10) {
+        asdf => 1,
+    };
+}
+
+/**
+@compilation_should_fail
+@stderr unknown type name `asdf`
+@stderr asdf => 1
+ */

tolk-tester/tests/invalid-symbol/err-2898.tolk

@@ -0,0 +1,16 @@
+fun main(a: int | slice) {
+    match (a) {
+        int => {
+            var cc: int = a;
+        },
+        slice => {
+            return cc;
+        },
+    };
+}
+
+/**
+@compilation_should_fail
+@stderr undefined symbol `cc`
+@stderr return cc;
+ */

tolk-tester/tests/invalid-syntax/err-3360.tolk

@@ -0,0 +1,10 @@
+
+fun main(r: int | slice) {
+    // after `is` we expect a type, parse `int?`, and expression becomes incorrect
+    return r is int ? 10 : 20;
+}
+
+/**
+@compilation_should_fail
+@stderr expected `;`, got `10`
+ */

tolk-tester/tests/invalid-syntax/err-3390.tolk

@@ -1,8 +1,8 @@
 fun main(): int {
-    ;; here is not a comment
+    ;; here not a comment
 }
 
 /**
 @compilation_should_fail
-@stderr error: expected `;`, got `is`
+@stderr error: expected `;`, got `not`
  */