[Tolk] Smart casts and control flow graph

With the introduction of nullable types, we want the
compiler to be smart in cases like
> if (x == null) return;
> // x is int now
or
> if (x == null) x = 0;
> // x is int now

These are called smart casts: when the type of variable
at particular usage might differ from its declaration.

Implementing smart casts is very challenging. They are based
on building control-flow graph and handling every AST vertex
with care. Actually, I represent cfg not a as a "graph with
edges". Instead, it's a "structured DFS" for the AST:
1) at every point of inferring, we have "current flow facts"
2) when we see an `if (...)`, we create two derived contexts
3) after `if`, finalize them at the end and unify
4) if we detect unreachable code, we mark that context
In other words, we get the effect of a CFG but in a more direct
approach. That's enough for AST-level data-flow.

Smart casts work for local variables and tensor/tuple indices.
Compilation errors have been reworked and now are more friendly.
There are also compilation warnings for always true/false
conditions inside if, assert, etc.

Author: tolk-vm

tolk-tester/tests/indexed-access.tolk

@@ -178,7 +178,7 @@ fun test114(f: int, s: int) {
 @method_id(115)
 fun test115() {
     var y = [[[[true]]]];
-    return (y, y.0.0.0.0 = !y.0.0.0.0, y.0);
+    return (y, ((((y).0).0).0).0 = !y.0.0.0.0, y.0);
 }
 
 @method_id(116)
@@ -248,7 +248,7 @@ fun test122(x: (int, int)) {
 @method_id(123)
 fun test123() {
     var t = [[10, 20]] as [[int,int]]?;
-    t!.0.0 = t!.0.1 = 100;
+    ((t!).0).0 = ((t!).0).1 = 100;
     return t;
 }
 

tolk-tester/tests/invalid-generics-13.tolk

@@ -6,6 +6,6 @@ fun cantApplyPlusOnNullable() {
 
 /**
 @compilation_should_fail
-@stderr while instantiating generic function `calcSum<int?>`
+@stderr in function `calcSum<int?>`
 @stderr can not apply operator `+` to `int?` and `int?`
  */

tolk-tester/tests/invalid-generics-14.tolk

@@ -0,0 +1,17 @@
+fun eq<X>(v: X) {}
+
+fun cantDeduceWhenNotInferred() {
+    // at type inferring (before type checking) they are unknown
+    var (x, y) = 2;
+
+    eq(x as int);   // ok (since execution doesn't reach type checking)
+    eq<int>(x);     // ok (since execution doesn't reach type checking)
+    eq(x);
+}
+
+/**
+@compilation_should_fail
+@stderr in function `cantDeduceWhenNotInferred`
+@stderr can not deduce X for generic function `eq<X>`
+@stderr eq(x);
+ */

tolk-tester/tests/invalid-generics-7.tolk

@@ -11,8 +11,7 @@ fun foo<X>(value: X) : X {
 
 /**
 @compilation_should_fail
-@stderr while instantiating generic function `foo<slice>`
-@stderr while instantiating generic function `bar<slice>`
+@stderr in function `bar<slice>`
 @stderr can not convert type `int` to return type `slice`
 @stderr return 1
  */

tolk-tester/tests/invalid-typing-11.tolk

@@ -3,6 +3,7 @@ fun failBitwiseNotOnBool() {
     if (~eq) {
         return 0;
     }
+    return -1;
 }
 
 /**

tolk-tester/tests/invalid-typing-19.tolk

@@ -0,0 +1,12 @@
+fun getNullableInt(): int? { return 5; }
+
+fun testCantApplyNotNullForAlwaysNull() {
+    var x: int? = getNullableInt();
+    if (x != null) { return 0; }
+    return x! + 1;
+}
+
+/**
+@compilation_should_fail
+@stderr operator `!` used for always null expression
+ */

tolk-tester/tests/invalid-typing-20.tolk

@@ -0,0 +1,15 @@
+fun getNullableInt(): int? { return 5; }
+
+fun testFlowContextAppliedInBinaryOperator() {
+    var x: int? = getNullableInt();
+    var y: int? = getNullableInt();
+    if ((y = null) < y) {
+        return -100;
+    }
+    return 0;
+}
+
+/**
+@compilation_should_fail
+@stderr can not apply operator `<` to `null` and `null`
+ */

tolk-tester/tests/invalid-typing-21.tolk

@@ -0,0 +1,14 @@
+fun getNullableInt(): int? { return 5; }
+
+fun testNeverTypeOccurs() {
+    var x: int? = getNullableInt();
+    if (x == null && x != null) {
+        return x + 0;
+    }
+    return 0;
+}
+
+/**
+@compilation_should_fail
+@stderr can not apply operator `+` to `never` and `int`
+ */

tolk-tester/tests/invalid-typing-22.tolk

@@ -0,0 +1,9 @@
+fun testLogicalAndNotConditionDoesntAffect(x: int?) {
+    var gt1 = x != null && x > 1;
+    return x + 0;
+}
+
+/**
+@compilation_should_fail
+@stderr can not apply operator `+` to `int?` and `int`
+ */

tolk-tester/tests/invalid-typing-23.tolk

@@ -0,0 +1,15 @@
+fun getTensor(): (int?, int?) { return (5, null); }
+
+fun testSmartCastsForFieldsDropAfterAssign() {
+    var t = getTensor();
+    if (t.0 != null && t.1 != null) {
+        t = getTensor();
+        return t.0 + t.1;
+    }
+    return -1;
+}
+
+/**
+@compilation_should_fail
+@stderr can not apply operator `+` to `int?` and `int?`
+ */