[Tolk] Support defaults for generic type arguments

This is now valid:
> struct Container<T = int?> { item: T = null }
> Container{}   // does Container<int?>

Defaults for Ts work both for functions and structs.
Their main purpose is to have the `never` default:
> struct WithOptField<T = never> { f: T; }
I've added a rule that if a struct has the `never` field,
it can be missed out from a literal while creation
(like it doesn't exist at all).
This will be used in stdlib later.

Author: tolk-vm

tolk-tester/tests/generics-4.tolk

@@ -0,0 +1,181 @@
+fun eqUnusedT<T=null>(v: int) { return v; }
+fun eqUnusedU<T, U = never>(v: T) { if (v is int123) { __expect_type(v as U, "never"); } return v; }
+
+fun dup<T1 = int?, T2 = slice?>(x: T1, y: T2): (T1, T2) { return (x, y) }
+
+struct Container1<T=int?> {
+    item: T;
+}
+
+fun getItemOf<T=never>(v: Container1<T>) {
+    return v.item;
+}
+
+struct WithDef1<T = null> {
+    body: T? = null;
+}
+
+fun getBodyOf<TBody = null>(o: WithDef1<TBody>) {
+    return o.body;
+}
+
+struct WithNever<T = never> {
+    f1: int;
+    f2: T;
+}
+
+fun eqNever<T = never>(o: WithNever<T>) { return o; }
+
+struct MyInit<TInit> {
+    value: coins;
+    data: TInit;
+}
+
+fun MyInit<TInit>.getValue(self) {
+    return self.value;
+}
+
+struct Parameters<TBody = never, TInit = never> {
+    bounce: bool;
+    body: TBody;
+    init: builder | MyInit<TInit> | null = null;
+}
+
+fun createParameters<TBody = null, TInit = null>(bounce: bool, body: TBody, data: TInit): Parameters<TBody, TInit> {
+    return { bounce, body, init: { value: ton("0"), data } };
+}
+
+fun mySend<TBody = never, TInit = never>(p: Parameters<TBody, TInit>): int {
+    var total = 0;
+    if (p.bounce) {
+        total += 1;
+    }
+    if (p.body !is never) {
+        assert(p.body is TBody, 101);
+        total += 10;
+    }
+    if (p.init is MyInit) {
+        total += 100 + p.init.getValue();
+    }
+    return total;
+}
+
+fun test1() {
+    eqUnusedT(100);
+    eqUnusedU(100);
+    eqUnusedU(beginCell());
+
+    __expect_type(dup(null, null), "(null, null)");
+    __expect_type(dup(createEmptyTuple(), 6), "(tuple, int)");
+}
+
+fun test2() {
+    var w1 = Container1 { item: 123 };
+    var w2 = Container1 { item: null };
+    __expect_type(w1, "Container1<int>");
+    __expect_type(w2, "Container1<null>");
+    __expect_type(getItemOf(w1), "int");
+    __expect_type(getItemOf(w2), "null");
+
+    __expect_type(getItemOf({item: null as slice?}), "slice?");
+    __expect_type(getItemOf({item: null}), "null");
+}
+
+@method_id(103)
+fun test3() {
+    __expect_type(WithNever{f1:10}, "WithNever<never>");
+    __expect_type(WithNever{f1:10,f2:20}, "WithNever<int>");
+
+    __expect_type(eqNever({f1:10}), "WithNever<never>");
+    __expect_type(eqNever({f1:10,f2:20}), "WithNever<int>");
+    __expect_type(eqNever({f1:10,f2:null}), "WithNever<null>");
+
+    var a: WithNever<never> = {f1:10};
+    return (a, WithNever{f1:20}, eqNever({f1:30}), 777, eqNever({f1:40,f2:40}));
+}
+
+@method_id(104)
+fun test4() {
+    __expect_type(getBodyOf({body: 123}), "int?");
+    __expect_type(getBodyOf({body: null}), "null");
+    __expect_type(getBodyOf({}), "null");
+
+    __expect_type(WithDef1{}, "WithDef1<null>");
+    __expect_type(WithDef1{}.body, "null");
+    __expect_type(WithDef1{body: null}.body, "null");
+    __expect_type(WithDef1{body: 123}.body, "int?");
+
+    return (getBodyOf({body: null}), getBodyOf({}), WithDef1{});
+}
+
+@method_id(105)
+fun test5() {
+    __expect_type(Parameters { bounce: true }, "Parameters<never, never>");
+    __expect_type(Parameters { bounce: false, body: 179 }, "Parameters<int, never>");
+    __expect_type(Parameters { bounce: true, init: beginCell() }, "Parameters<never, never>");
+    __expect_type(Parameters { bounce: false, body: beginCell(), init: { value: 123, data: 123 } }, "Parameters<builder, int>");
+
+    __expect_type(createParameters(true, null, null), "Parameters<null, null>");
+    __expect_type(createParameters(true, beginCell(), "123"), "Parameters<builder, slice>");
+
+    __expect_type(createParameters(true, null, null).body, "null");
+    __expect_type(createParameters(true, 123, null).body, "int");
+    __expect_type(createParameters(true, null, null).init, "builder | MyInit<null> | null");
+    __expect_type(createParameters(true, 123, 456).init, "builder | MyInit<int> | null");
+
+    return (createParameters(true, null, null), 777, createParameters(false, 123, 456));
+}
+
+@method_id(106)
+fun test6() {
+    var p: Parameters<int, cell> = {
+        bounce: true,
+        body: 123,
+        init: { value: ton("0"), data: beginCell().endCell() }
+    };
+    return (p.body is int, p.init is cell, p.init is MyInit, p.init is MyInit && p.init.data.depth() == 0);
+}
+
+@method_id(107)
+fun test7() {
+    __expect_type(Parameters{ bounce: false, body: 123, init: { value: ton("0"), data: beginCell() }}, "Parameters<int, builder>");
+    var v1 = mySend({ bounce: true });
+    var v2 = mySend({ bounce: false, body: 123, init: beginCell() });
+    var v3 = mySend({ bounce: false, body: 123, init: { value: ton("0"), data: beginCell() }});
+    var v4 = mySend({ bounce: true, init: { value: 16, data: null as [int]? }});
+    return (v1, v2, v3, v4);
+}
+
+fun main() {
+}
+
+/**
+@testcase | 103 |      | 10 20 30 777 40 40
+@testcase | 104 |      | (null) (null) (null)
+@testcase | 105 |      | -1 (null) 0 (null) 133 777 0 123 0 456 132
+@testcase | 106 |      | -1 0 -1 -1
+@testcase | 107 |      | 1 10 110 117
+
+@fif_codegen DECLPROC eqUnusedT<null>
+@fif_codegen DECLPROC eqUnusedU<builder,never>
+@fif_codegen DECLPROC mySend<never,never>
+@fif_codegen DECLPROC mySend<int,never>
+@fif_codegen DECLPROC mySend<int,builder>
+@fif_codegen DECLPROC mySend<never,[int]?>
+
+@fif_codegen
+"""
+  test6 PROC:<{                 //
+    NEWC                        //  '8
+    ENDC                        //  p.init.USlot2
+    -1 PUSHINT                  //  p.init.USlot2 '11=-1
+    FALSE                       //  p.init.USlot2 '11=-1 '12
+    TRUE                        //  p.init.USlot2 '11=-1 '12 '14
+    s0 s3 XCHG                  //  '14 '11=-1 '12 p.init.USlot2
+    CDEPTH                      //  '14 '11=-1 '12 '19
+    0 EQINT                     //  '14 '11=-1 '12 '21
+    0 NEQINT                    //  '14 '11=-1 '12 '18
+    s1 s3 s0 XCHG3              //  '11=-1 '12 '14 '18
+  }>
+"""
+ */

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

@@ -11,6 +11,6 @@ fun main() {
 
 /**
 @compilation_should_fail
-@stderr field `item` missed in initialization of struct `Wrapper<T>`
+@stderr can not deduce T for generic struct `Wrapper<T>`
 @stderr = Wrapper {
  */

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

@@ -0,0 +1,16 @@
+struct Wrapper<T = int> {
+    item: T;
+    value: int;
+}
+
+fun main() {
+    var c = Wrapper {
+        value: null
+    };
+}
+
+/**
+@compilation_should_fail
+@stderr field `item` missed in initialization of struct `Wrapper<int>`
+@stderr = Wrapper {
+ */

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

@@ -0,0 +1,25 @@
+struct Data<T> {
+    data: T;
+}
+
+struct Parameters<TBody, TData> {
+    bounce: bool,
+    dest: slice | Data<TData>,
+    body: TBody,
+}
+
+fun f<TBody, TData>(params: Parameters<TBody, TData>) {
+}
+
+fun main() {
+    f({
+        dest: "sss",
+        body: 123,
+    })
+}
+
+/**
+@compilation_should_fail
+@stderr can not deduce TData for generic struct `Parameters<TBody, TData>`
+@stderr dest: "sss"
+ */

tolk-tester/tests/invalid-typing/err-6380.tolk

@@ -0,0 +1,14 @@
+struct A {
+    f1: never;
+}
+
+fun main() {
+    var a: A = {};      // f1 is never, can be omitted
+    a.f1 = 100;
+}
+
+/**
+@compilation_should_fail
+@stderr can not assign `int` to field of type `never`
+@stderr a.f1 = 100
+ */

tolk-tester/tests/struct-tests.tolk

@@ -474,6 +474,18 @@ fun test33(): WithDefaults {
     return { f2: 5, f3: null };
 }
 
+struct WithNever {
+    f1: int;
+    f2: never;
+    f3: int;
+}
+
+@method_id(134)
+fun test34() {
+    var o1: WithNever = { f1: 10, f3: 20 };   // f2 is `never`, it can be omitted
+    __expect_type(o1.f2, "never");
+    return o1;
+}
 
 
 fun main(x: int8, y: MInt) {
@@ -526,6 +538,7 @@ type PointAlias = Point;
 @testcase | 131 |      | 5 141 (null) 141 (null) 0 777 0 0 -1 777 0 -1
 @testcase | 132 |      | 10 20 10 0 0 20 0 0 0 0
 @testcase | 133 |      | -1 0 5 (null) (null) (null) 0 0 46
+@testcase | 134 |      | 10 20
 
 @fif_codegen
 """

tolk/ast-from-tokens.cpp

@@ -279,9 +279,15 @@ static V<ast_genericsT_list> parse_genericsT_list(Lexer& lex) {
   lex.expect(tok_lt, "`<`");
   while (true) {
     lex.check(tok_identifier, "T");
+    SrcLocation locT = lex.cur_location();
     std::string_view nameT = lex.cur_str();
-    genericsT_items.emplace_back(createV<ast_genericsT_item>(lex.cur_location(), nameT));
     lex.next();
+    AnyTypeV default_type = nullptr;
+    if (lex.tok() == tok_assign) {          // <T = int?>
+      lex.next();
+      default_type = parse_type_expression(lex);
+    }
+    genericsT_items.emplace_back(createV<ast_genericsT_item>(locT, nameT, default_type));
     if (lex.tok() != tok_comma) {
       break;
     }

tolk/ast-replicator.h

@@ -211,7 +211,7 @@ class ASTReplicator final {
     return createV<ast_identifier>(v->loc, v->name);
   }
   static V<ast_genericsT_item> clone(V<ast_genericsT_item> v) {
-    return createV<ast_genericsT_item>(v->loc, v->nameT);
+    return createV<ast_genericsT_item>(v->loc, v->nameT, clone(v->default_type_node));
   }
   static V<ast_genericsT_list> clone(V<ast_genericsT_list> v) {
     return createV<ast_genericsT_list>(v->loc, clone(v->get_items()));

tolk/ast.h

@@ -1127,12 +1127,14 @@ struct Vertex<ast_asm_body> final : ASTStatementVararg {
 template<>
 // ast_genericsT_item is generics T at declaration
 // example: `fun f<T1, T2>` has a list of 2 generic Ts
+// example: `struct Params<TInit=null>` has 1 generic T with default
 struct Vertex<ast_genericsT_item> final : ASTOtherLeaf {
   std::string_view nameT;
+  AnyTypeV default_type_node;       // exists for `<T = int>`, nullptr otherwise
 
-  Vertex(SrcLocation loc, std::string_view nameT)
+  Vertex(SrcLocation loc, std::string_view nameT, AnyTypeV default_type_node)
     : ASTOtherLeaf(ast_genericsT_item, loc)
-    , nameT(nameT) {}
+    , nameT(nameT), default_type_node(default_type_node) {}
 };
 
 template<>

tolk/builtins.cpp

@@ -1119,7 +1119,7 @@ void define_builtins() {
   TypePtr Never = TypeDataNever::create();
 
   TypePtr typeT = TypeDataGenericT::create("T");
-  const GenericsDeclaration* declGenericT = new GenericsDeclaration(std::vector<std::string_view>{"T"}, 0);
+  const GenericsDeclaration* declGenericT = new GenericsDeclaration(std::vector<GenericsDeclaration::ItemT>{{"T", nullptr}}, 0);
 
   std::vector ParamsInt1 = {Int};
   std::vector ParamsInt2 = {Int, Int};