[Tolk] Fix parsing sequential as operator

Author: tolk-vm

tolk-tester/tests/match-by-expr-tests.tolk

@@ -81,7 +81,7 @@ fun test7(x: int8) {
 
 @method_id(108)
 fun test8(x: int) {
-    var r1 = match (x is int) { false => 0, else => 10 };
+    var r1 = match (x is int && x is int is bool) { false => 0, else => 10 };
     match (x) { }
     match (x * 0) { 1 => {} else => { r1 += 20; } }
     return r1;

tolk-tester/tests/parse-address.tolk

@@ -142,12 +142,14 @@ fun main() {
         (cc1 as slice).bitsEqual(((cc2 as slice) as address) as slice),
         createAddressNone() == cc1,
         createAddressNone() == address.createNone(),
-        check0(address("0:FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFfffffffffffffffffffffffffffff"))
+        check0(address("0:FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFfffffffffffffffffffffffffffff")),
+        cc1 == cc1 as bits267 as address,
+        cc1 == cc1 as slice as bits999 as address,
     );
 }
 
 /**
-@testcase | 0   |   | -1 0 -1 0 -1
+@testcase | 0   |   | -1 0 -1 0 -1 -1 -1
 
 @fif_codegen
 """

tolk/ast-from-tokens.cpp

@@ -951,23 +951,24 @@ static AnyExprV parse_expr75(Lexer& lex) {
   return parse_expr80(lex);
 }
 
-// parse E as / is / !is <type>
+// parse E as / is / !is <type> (left-to-right)
 static AnyExprV parse_expr40(Lexer& lex) {
   AnyExprV lhs = parse_expr75(lex);
-  if (lex.tok() == tok_as) {
-    SrcLocation loc = lex.cur_location();
-    lex.next();
-    AnyTypeV cast_to_type = parse_type_from_tokens(lex);
-    lhs = createV<ast_cast_as_operator>(loc, lhs, cast_to_type);
-  } else if (lex.tok() == tok_is) {
+  TokenType t = lex.tok();
+  while (t == tok_as || t == tok_is) {
     SrcLocation loc = lex.cur_location();
     lex.next();
     AnyTypeV rhs_type = parse_type_from_tokens(lex);
-    bool is_negated = lhs->kind == ast_not_null_operator;   // `a !is ...`, now lhs = `a!`
-    if (is_negated) {
-      lhs = lhs->as<ast_not_null_operator>()->get_expr();
+    if (t == tok_as) {
+      lhs = createV<ast_cast_as_operator>(loc, lhs, rhs_type);
+    } else {
+      bool is_negated = lhs->kind == ast_not_null_operator;   // `a !is ...`, now lhs = `a!`
+      if (is_negated) {
+        lhs = lhs->as<ast_not_null_operator>()->get_expr();
+      }
+      lhs = createV<ast_is_type_operator>(loc, lhs, rhs_type, is_negated);
     }
-    lhs = createV<ast_is_type_operator>(loc, lhs, rhs_type, is_negated);
+    t = lex.tok();
   }
   return lhs;
 }

tolk/pipe-ast-to-legacy.cpp

@@ -1009,6 +1009,16 @@ static std::vector<var_idx_t> transition_expr_to_runtime_type_impl(std::vector<v
     return rvect;
   }
 
+  // pass `bits267` to `address`
+  if (target_type == TypeDataAddress::create() && original_type->try_as<TypeDataBitsN>()) {
+    return rvect;
+  }
+
+  // pass `address` to `bits267`
+  if (original_type == TypeDataAddress::create() && target_type->try_as<TypeDataBitsN>()) {
+    return rvect;
+  }
+
   // pass a typed tuple `[int, int]` to an untyped (via `as` operator)
   if (original_type->try_as<TypeDataBrackets>() && target_type->try_as<TypeDataTuple>()) {
     return rvect;

tolk/type-system.cpp

@@ -955,7 +955,7 @@ bool TypeDataContinuation::can_be_casted_with_as_operator(TypePtr cast_to) const
 }
 
 bool TypeDataAddress::can_be_casted_with_as_operator(TypePtr cast_to) const {
-  if (cast_to == TypeDataSlice::create()) {
+  if (cast_to == TypeDataSlice::create() || cast_to->try_as<TypeDataBitsN>()) {
     return true;
   }
   if (const TypeDataUnion* to_union = cast_to->try_as<TypeDataUnion>()) {