[Tolk] Enhance overload resolution rules for method receivers

This commit focuses on overload resolution for generic methods:
strict ordering, type shapes, etc.

Author: tolk-vm

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

@@ -8,7 +8,7 @@ fun Container<T?>.createFrom<U>(item: U): Container<T?> {
 
 fun cantUseAsNonCall() {
     Container<int?>.createFrom<slice>;              // ok
-    Container<slice>.createFrom<Container<int>>;    // ok
+    Container<slice?>.createFrom<Container<int>>;   // ok
 
     Container<int?>.createFrom;
 }

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

@@ -0,0 +1,17 @@
+struct Wrapper<T> { item: T }
+
+type AssetBuilder = builder
+type BalanceBuilder = builder
+
+fun Wrapper<AssetBuilder>.validate(self) { return 0 }
+
+fun main() {
+    var b: BalanceBuilder = beginCell();
+    Wrapper{item:b}.validate();
+}
+
+/**
+@compilation_should_fail
+@stderr method `validate` not found for type `Wrapper<BalanceBuilder>`
+@stderr but it exists for type `Wrapper<AssetBuilder>`
+ */

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

@@ -0,0 +1,13 @@
+fun int.realValue(self): int8 { return 1 }
+fun int?.realValue(self): uint256 { return 1 }
+
+fun main() {
+    (5 as int8).realValue();
+}
+
+/**
+@compilation_should_fail
+@stderr call to method `realValue` for type `int8` is ambiguous
+@stderr candidate function: `int.realValue`
+@stderr candidate function: `int?.realValue`
+ */

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

@@ -0,0 +1,13 @@
+fun int8.doSome2() {}
+fun int16.doSome2() {}
+
+fun main() {
+    int.doSome2();
+}
+
+/**
+@compilation_should_fail
+@stderr call to method `doSome2` for type `int` is ambiguous
+@stderr candidate function: `int8.doSome2`
+@stderr candidate function: `int16.doSome2`
+ */

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

@@ -0,0 +1,18 @@
+struct MyMap<K, V>
+
+fun MyMap<K, slice>.amb(self) { return 0 }
+fun MyMap<int, V>.amb(self) { return 0 }
+
+fun main() {
+    MyMap<int8, slice>{}.amb();   // ok
+    MyMap<int, slice?>{}.amb();   // ok
+
+    MyMap<int, slice>{}.amb();
+}
+
+/**
+@compilation_should_fail
+@stderr call to method `amb` for type `MyMap<int, slice>` is ambiguous
+@stderr candidate function: `MyMap<K,slice>.amb` with K=`int`
+@stderr candidate function: `MyMap<int,V>.amb` with V=`slice`
+ */

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

@@ -0,0 +1,17 @@
+struct MyMap<K, V>
+
+fun MyMap<K, slice>.amb(self) { return 0 }
+fun MyMap<int, V>.amb(self) { return 0 }
+
+fun main() {
+    MyMap<(int, int, MyMap<int, coins>), slice>{}.amb();   // ok
+    MyMap<int, cell|()>{}.amb();   // ok
+
+    MyMap<cell, builder>{}.amb();
+}
+
+/**
+@compilation_should_fail
+@stderr method `amb` not found for type `MyMap<cell, builder>`
+@stderr (but it exists for type `MyMap<K, slice>`)
+ */

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

@@ -0,0 +1,19 @@
+type AssetBuilder = builder
+type BalanceBuilder = builder
+
+fun AssetBuilder.validate(self) { return 0 }
+fun BalanceBuilder.validate(self) { return 0 }
+
+fun main() {
+    (beginCell() as AssetBuilder).validate();       // ok
+    (beginCell() as BalanceBuilder).validate();     // ok
+
+    beginCell().validate();
+}
+
+/**
+@compilation_should_fail
+@stderr call to method `validate` for type `builder` is ambiguous
+@stderr candidate function: `AssetBuilder.validate`
+@stderr candidate function: `BalanceBuilder.validate`
+ */

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

@@ -0,0 +1,12 @@
+struct Wrapper<T> { item: T; }
+fun Wrapper<T?>.createNull(): Wrapper<T?> { return { item: null } }
+
+fun main() {
+    Wrapper<int>.createNull();
+}
+
+/**
+@compilation_should_fail
+@stderr method `createNull` not found for type `Wrapper<int>`
+@stderr (but it exists for type `Wrapper<T?>`)
+ */

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

@@ -0,0 +1,17 @@
+struct Point {
+    x: int8
+    y: int8
+}
+
+fun Cell<T>.myMethod<U>(self, v: U): int 
+    asm "DROP" "HASHCU"
+
+fun main() {
+    Point{x:10,y:20}.toCell().myMethod(4);      // ok
+    Point{x:10,y:20}.toCell().myMethod((4, 5));
+}
+
+/**
+@compilation_should_fail
+@stderr can not call `Cell<T>.myMethod<U>` with U=(int, int), because it occupies 2 stack slots in TVM, not 1
+ */

tolk-tester/tests/methods-tests.tolk

@@ -191,11 +191,11 @@ fun T?.arbitraryMethod(self): never { throw 123; }
 
 fun test12() {
     __expect_type(10.arbitraryMethod(), "int?");
-    __expect_type((10 as int8?).arbitraryMethod(), "int?");
     __expect_type((10 as coins?)!.arbitraryMethod(), "int?");
 
-    __expect_type(null.arbitraryMethod(), "int?");
-    __expect_type((10 as coins?).arbitraryMethod(), "int?");
+    __expect_type((10 as int8?).arbitraryMethod(), "never");
+    __expect_type(null.arbitraryMethod(), "never");
+    __expect_type((10 as coins?).arbitraryMethod(), "never");
 
     __expect_type(Wrapper { item: 10 }.arbitraryMethod(), "Wrapper<MInt>");
     __expect_type(Wrapper<int> { item: 10 as int8 }.arbitraryMethod(), "Wrapper<MInt>");
@@ -280,7 +280,7 @@ fun Wrapper<T>.createFrom<U>(item: U): Wrapper<T> { return {item}; }
 fun test18() {
     __expect_type(10.copy, "(int) -> int");
     __expect_type(Wrapper{item:null as int8?}.copy, "(Wrapper<int8?>) -> Wrapper<int8?>");
-    __expect_type(Wrapper<int>.createNull, "() -> Wrapper<int?>");
+    __expect_type(Wrapper<int?>.createNull, "() -> Wrapper<int?>");
     __expect_type(Wrapper<Wrapper<slice?>?>.createNull, "() -> Wrapper<Wrapper<slice?>?>");
     __expect_type(Wrapper<int?>.createFrom<int8>, "(int8) -> Wrapper<int?>");
 
@@ -319,7 +319,7 @@ fun main() {}
 @testcase | 107 |        | 2 1 -1
 @testcase | 108 | 5      | 17 5
 @testcase | 109 |        | 5 100500 20 30 5 5 31
-@testcase | 110 |        | [ 2 3 1 1 3 1 1 ] -1
+@testcase | 110 |        | [ 2 3 1 1 1 1 1 ] -1
 @testcase | 111 |        | [ 1 2 3 3 2 ]
 @testcase | 113 |        | 0 -1 -1 -1 0 -1
 @testcase | 114 |        | -1 -1 0 0 0