[Tolk] More correctly generate a serialization prefix tree for nullable unions

Now, treat `T?` as `Maybe<T>` even if T is a union.
Example: A|B|C|D|null => 0 | 100+A | 101+B | 110+C | 111+D.
If no `null`, just distribute sequentially: A|B|C => 00+A | 01+B | 10+C

Author: tolk-vm

tolk-tester/tests/lazy-load-tests.tolk

@@ -241,6 +241,18 @@ struct WithGlobalModifier {
     n: int8;
 }
 
+struct WithN5 { n: uint5 }
+type U111 = int8 | int16 | WithN5 | bits100
+struct WithU111 {
+    a: U111
+    b: U111?
+    bit: bool
+}
+fun WithU111.getSlice_a8_bnull(): slice asm "b{000000000101} PUSHSLICE"
+fun WithU111.getSlice_a16_b8(): slice asm "b{010000000000000001100000000011} PUSHSLICE"
+fun WithU111.getSlice_a8_b5(): slice asm "b{0000000001110111111} PUSHSLICE"
+fun WithU111.getSlice_a8_b5_nobit(): slice asm "b{000000000111011111} PUSHSLICE"
+
 
 @noinline
 fun contract.getFakeData(seqno: int): Cell<WalletStorage> {
@@ -981,6 +993,21 @@ fun demo158() {
     return (m2.n, gModByCustom, after1);  // also modifies by skipping (unpack called)
 }
 
+@method_id(159)
+fun demo159() {
+    val p1 = lazy WithU111.fromSlice(WithU111.getSlice_a8_bnull());
+    val p2 = lazy WithU111.fromSlice(WithU111.getSlice_a16_b8());
+    val p3 = lazy WithU111.fromSlice(WithU111.getSlice_a8_b5());
+    val p4 = lazy WithU111.fromSlice(WithU111.getSlice_a8_b5_nobit());
+
+    val p1_bit = p1.bit;
+    val p2_bit = p2.bit;
+    val p3_bit = p3.bit;
+    val p4_b = p4.b;
+
+    return (p1_bit, p2_bit, (p3.b is WithN5) ? p3.b.n as int : 777, p3_bit, (p4_b is WithN5) ? p4_b.n as int: 777);
+}
+
 
 @method_id(200)
 fun demo200() {
@@ -1601,10 +1628,10 @@ fun main() {
 @testcase | 113 | x{03ffff}       | -1
 @testcase | 113 | x{04000000FF}   | 255
 @testcase | 114 | x{0110}         | 16 1
-@testcase | 114 | x{020f}         | [ -15 ] typeid-25
+@testcase | 114 | x{020f}         | [ -15 ] typeid-27
 @testcase | 114 | x{03}           | -1 1
 @testcase | 114 | x{03ffff}       | -1 1
-@testcase | 114 | x{04000000FF}   | [ 255 ] typeid-25
+@testcase | 114 | x{04000000FF}   | [ 255 ] typeid-27
 @testcase | 115 | x{08}           | 8 42
 @testcase | 115 | x{88}           | 0 2
 @testcase | 115 | x{83}           | -1 2
@@ -1669,6 +1696,7 @@ fun main() {
 @testcase | 156 | x{FF10}         | -100
 @testcase | 157 |                 | -1
 @testcase | 158 |                 | 2 10 255
+@testcase | 159 |                 | -1 -1 31 -1 31
 
 @testcase | 200 |                 | 1
 @testcase | 201 |                 | 1 2 -1

tolk-tester/tests/pack-unpack-4.tolk

@@ -38,10 +38,10 @@ fun test1() {
 
 type Union_8_16_32_n = int8 | null | int16 | int32;
 
-fun ans102n_8(): slice asm "b{0100001111} PUSHSLICE";
-fun ans102n_16(): slice asm "b{100000000000001111} PUSHSLICE";
-fun ans102n_32(): slice asm "b{1100000000000000000000000000001111} PUSHSLICE";
-fun ans102n_null(): slice asm "b{00} PUSHSLICE";
+fun ans102n_8(): slice asm "b{10000001111} PUSHSLICE";
+fun ans102n_16(): slice asm "b{1010000000000001111} PUSHSLICE";
+fun ans102n_32(): slice asm "b{11000000000000000000000000000001111} PUSHSLICE";
+fun ans102n_null(): slice asm "b{0} PUSHSLICE";
 
 @method_id(102)
 fun test2() {
@@ -65,10 +65,10 @@ fun ans104_8(): slice asm "b{0000001111} PUSHSLICE";
 fun ans104_16(): slice asm "b{010000000000001111} PUSHSLICE";
 fun ans104_32(): slice asm "b{1000000000000000000000000000001111} PUSHSLICE";
 
-fun ans104n_8(): slice asm "b{0100001111} PUSHSLICE";
-fun ans104n_16(): slice asm "b{100000000000001111} PUSHSLICE";
-fun ans104n_32(): slice asm "b{1100000000000000000000000000001111} PUSHSLICE";
-fun ans104n_null(): slice asm "b{00} PUSHSLICE";
+fun ans104n_8(): slice asm "b{10000001111} PUSHSLICE";
+fun ans104n_16(): slice asm "b{1010000000000001111} PUSHSLICE";
+fun ans104n_32(): slice asm "b{11000000000000000000000000000001111} PUSHSLICE";
+fun ans104n_null(): slice asm "b{0} PUSHSLICE";
 
 @method_id(104)
 fun test4() {

tolk-tester/tests/pack-unpack-5.tolk

@@ -160,7 +160,7 @@ struct Test9_bits4 { f: bits4; }
 type Test9_f1 = int32 | int64 | int128;                         // auto-generated 2-bit prefix
 type Test9_f2 = int32 | Inner8_2;                               // auto-generated 1-bit prefix (Either)
 type Test9_f3 = bits1 | Test9_bits2 | bits3 | bits4 | bits5;    // auto-generated 3-bit prefix
-type Test9_f4 = bits1 | Test9_bits2 | bits3 | Test9_bits4?;     // auto-generated 3-bit prefix
+type Test9_f4 = bits1 | Test9_bits2 | bits3 | Test9_bits4?;     // auto-generated 0 / 100/101/110/111
 
 @method_id(109)
 fun test9() {
@@ -213,7 +213,7 @@ fun main() {
 @testcase | 106 | | [ 64 64 0 0 ] [ 5 37 1 1 ] [ 5 65 0 1 ]
 @testcase | 107 | | [ 16 16 0 0 ] [ 16 16 0 0 ]
 @testcase | 108 | | [ 10 275 0 0 ] [ 34 158 0 0 ] [ 47 1143 0 1 ]
-@testcase | 109 | | [ 34 130 0 0 ] [ 33 159 0 0 ] [ 4 8 0 0 ] [ 3 7 0 0 ]
+@testcase | 109 | | [ 34 130 0 0 ] [ 33 159 0 0 ] [ 4 8 0 0 ] [ 1 7 0 0 ]
 @testcase | 110 | | [ 32 9999 0 4 ] [ 33 9999 0 8 ]
 @testcase | 111 | | [ 1023 1023 0 1 ] [ 0 0 2 2 ]
 @testcase | 120 | | 16 4128 1 1

tolk/pack-unpack-serializers.cpp

@@ -1146,13 +1146,16 @@ std::vector<PackOpcode> auto_generate_opcodes_for_union(TypePtr union_type, std:
 
   // okay, none of the opcodes are specified, generate a prefix tree;
   // examples: `int32 | int64 | int128` / `int32 | A | null` / `A | B` / `A | B | C`;
-  // create prefixes `0b00 0b01 0b10` / `0b01 0b10 0b00` (use 0b00 for null if exists):
-  // for 3/4 variants — two bits, for 5 — three
-  int prefix_len = static_cast<int>(std::ceil(std::log2(t_union->size())));
-  int cur_prefix = has_null ? 1 : 0;    // will use 0b00 for null, so start with 0b01
+  // if `null` exists, it's 0, all others are 1+tree: A|B|C|D|null => 0 | 100+A | 101+B | 110+C | 111+D;
+  // if no `null`, just distribute sequentially: A|B|C => 00+A | 01+B | 10+C
+  int n_without_null = t_union->size() - has_null; 
+  int prefix_len = static_cast<int>(std::ceil(std::log2(n_without_null)));
+  int cur_prefix = 0;
   for (TypePtr variant : t_union->variants) {
     if (variant == TypeDataNullLiteral::create()) {
-      result.emplace_back(0, prefix_len);
+      result.emplace_back(0, 1);
+    } else if (has_null) {
+      result.emplace_back((1<<prefix_len) + (cur_prefix++), prefix_len + 1);
     } else {
       result.emplace_back(cur_prefix++, prefix_len);
     }