[Tolk] Implement structures that work like tensors on a stack

Support declaring structures with arbitrary fields
and creating objects very similar to TS syntax.
Structs are actually tensors on a stack, and accessing their
fields behave exactly as accessing tensor's elements by index.
As a consequence, recurring struct fields doesn't work;
it will lead to infinity size.

All features of type system (nullables, unions) seamlessly
work with structures. A struct with 1 field has no extra
overhead, it's just a field on a stack.

Author: tolk-vm

tolk-tester/tests/allow-post-modification.tolk

@@ -112,6 +112,16 @@ fun test_assign_tensor_global(x: (int, int)) {
     return (x, x = (20, 30), fs = x.multens((1, 2)), fs.multens(multens(mutate x, (-1, -1))), x, fs);
 }
 
+struct Point1D {
+    c: int;
+}
+
+@method_id(25)
+fun test_with_single_slot_struct(x: Point1D) {
+    var result = (x, x.c += 10, [x, x.c += 20, eq(x.c -= 50), x.c], eq2((x.c, x.c *= eq(x.c /= 2))));
+    return result;
+}
+
 fun main() {
 }
 
@@ -132,6 +142,7 @@ fun main() {
 @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
+@testcase | 25 | 100 | 100 110 [ 110 130 80 80 ] 80 3200
 
 @fif_codegen
 """
@@ -147,5 +158,5 @@ fun main() {
     // x.0 x.1
 """
 
-@code_hash 61280273714870328160131559159866470128402169974050439159015534193532598351244
+@code_hash 6737917279814799680932710799951154408447028229503449454536845752635763933556
 */

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

@@ -0,0 +1,10 @@
+struct B { a: A }
+struct A { b: BAlias }
+
+type BAlias = B;
+
+/**
+@compilation_should_fail
+@stderr struct `B` size is infinity due to recursive fields
+@stderr struct B {
+ */

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

@@ -0,0 +1,22 @@
+struct A {
+    value: int;
+}
+
+struct B {
+    data: slice;
+}
+
+fun main() {
+    var r1: A | B = A { value: 10 };
+    var r2: A | null = { value: 10 };
+    var r3: A | int | builder = { value: 10 };
+
+    var r4: A | B = { value: 20 };
+}
+
+/**
+@compilation_should_fail
+@stderr can not detect struct name
+@stderr use either `var v: StructName = { ... }` or `var v = StructName { ... }`
+@stderr { value: 20 }
+ */

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

@@ -0,0 +1,13 @@
+fun increment(mutate x: int) {
+    x += 1;
+}
+
+fun checkCantMutateFieldOfImmutableTensor() {
+    val t = (0, 1);
+    increment(mutate ((t!)).0);
+}
+
+/**
+@compilation_should_fail
+@stderr modifying immutable variable `t`
+ */

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

@@ -0,0 +1,13 @@
+struct User {
+    id: int;
+}
+
+fun cantInstantiateNonGenericStruct() {
+    var u = User<int> { id: 3 };
+}
+
+/**
+@compilation_should_fail
+@stderr generic T not expected here
+@stderr User<int>
+ */

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

@@ -0,0 +1,15 @@
+struct User {
+    id: int;
+}
+
+type UserAlias = User;
+
+fun cantInstantiateNonGenericStruct() {
+    var u = UserAlias<int> { id: 3 };
+}
+
+/**
+@compilation_should_fail
+@stderr generic T not expected here
+@stderr UserAlias<int>
+ */

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

@@ -0,0 +1,13 @@
+struct User {
+    id: int;
+    name: slice;
+}
+
+fun main() {
+    var u: User = { id: 1 };
+}
+
+/**
+@compilation_should_fail
+@stderr field `name` missed in initialization of struct `User`
+ */

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

@@ -0,0 +1,21 @@
+struct NumberFields {
+    `-1`: int;
+    `0`: int;
+    `100500`: int;
+}
+
+fun main() {
+    var b: NumberFields = { `-1`: -1, `0`: 0, `100500`: 100500 };
+    b.0;                // ok
+    b.`0`;              // ok
+    b.`-1`;             // ok
+    b.`100500`;         // ok
+    b.100500;           // ok
+    b.123;
+}
+
+/**
+@compilation_should_fail
+@stderr field `123` doesn't exist in type `NumberFields`
+@stderr b.123
+ */

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

@@ -0,0 +1,12 @@
+struct value { id: int; }
+
+fun main() {
+    var value = 100;
+    var obj = value { id: 100 };
+}
+
+/**
+@compilation_should_fail
+@stderr `value` does not name a struct
+@stderr obj = value
+ */

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

@@ -0,0 +1,9 @@
+fun checkCantMutateFieldOfImmutableTuple() {
+    val ks = null as [int, [int, [int]]]?;
+    ks!.1.1.0 = 10;
+}
+
+/**
+@compilation_should_fail
+@stderr modifying immutable variable `ks`
+ */