[Tolk] Optimization: generate IFJMP inside match arms

Then `match` is the last statement,
or is immediately followed by `return`,
generate not `IF...ELSE` to Fift output,
but `IFJMP...`.
Same for `if/else` statement.

Author: tolk-vm

tolk-tester/tests/if-else-tests.tolk

@@ -1,3 +1,5 @@
+global t: tuple;
+
 @method_id(101)
 fun test1(x: int): int {
     if (x > 200) {
@@ -100,6 +102,86 @@ fun test8(op: int) {
     return (withNoElse(op), withElse(op), withMatch(op));
 }
 
+fun demo9_1(x: int) {
+    if (x > 0) { t.push(123); }
+    else { t.push(456) }
+}
+
+fun demo9_2(x: int) {
+    if (x > 0) { t.push(123); }
+}
+
+fun demo9_3(x: int) {
+    if (x > 0) { t.push(123); }
+    return;
+}
+
+fun demo9_4(x: int) {
+    if (x != -100) {
+        if (x > 0) { t.push(123); }
+        return;
+    }
+}
+
+@method_id(109)
+fun test9(x: int) {
+    t = createEmptyTuple();
+    demo9_1(x); demo9_2(x); demo9_3(x); demo9_4(x);
+    return t;
+}
+
+fun demo10_1(x: int) {
+    match(x) {
+        0 => t.push(123),
+        1 => t.push(456),
+    }
+}
+
+fun demo10_2(x: int) {
+    if (x != -100) {
+        match (x) {
+            0 => t.push(123),
+            else => t.push(456)
+        }
+        return;
+    }
+    t.push(789)
+}
+
+@method_id(110)
+fun test10(x: int) {
+    t = createEmptyTuple();
+    demo10_1(x); demo10_2(x);
+    return t;
+}
+
+fun demo_neg_11_1(mutate x: int) {
+    match (x) {
+        -1 => { x = 0; }
+        else => { x = 1; }
+    }
+}
+
+fun justVoidPush() {
+    t.push(100);
+}
+
+fun demo_neg_11_2(x: int) {
+    match (x) {
+        -1 => t.push(123),
+        else => t.push(456)
+    }
+    return justVoidPush();
+}
+
+@method_id(111)
+fun test11(x: int) {
+    t = createEmptyTuple();
+    demo_neg_11_1(mutate x);
+    demo_neg_11_2(x);
+    return (x, t);
+}
+
 fun main() {
 
 }
@@ -125,6 +207,11 @@ fun main() {
 @testcase | 106 | 5  | 5000
 @testcase | 108 | 123 | 100 100 100
 @testcase | 108 | 345 | 300 300 300
+@testcase | 109 | 10  | [ 123 123 123 123 ]
+@testcase | 109 | -10 | [ 456 ]
+@testcase | 110 | 0   | [ 123 123 ]
+@testcase | 110 | 5   | [ 456 ]
+@testcase | 111 | 5   | 1 [ 456 100 ]
 
 @fif_codegen
 """
@@ -214,4 +301,88 @@ fun main() {
     255 THROW
   }>
 """
+
+@fif_codegen
+"""
+  demo9_1 PROC:<{
+    0 GTINT
+    IFJMP:<{
+      t GETGLOB
+      123 PUSHINT
+      TPUSH
+      t SETGLOB
+    }>
+    t GETGLOB
+    456 PUSHINT
+    TPUSH
+    t SETGLOB
+  }>
+"""
+
+@fif_codegen
+"""
+  demo9_2 PROC:<{
+    0 GTINT
+    IFJMP:<{
+      t GETGLOB
+      123 PUSHINT
+      TPUSH
+      t SETGLOB
+    }>
+  }>
+"""
+
+@fif_codegen
+"""
+  demo9_3 PROC:<{
+    0 GTINT
+    IFJMP:<{
+      t GETGLOB
+      123 PUSHINT
+      TPUSH
+      t SETGLOB
+    }>
+  }>
+"""
+
+@fif_codegen
+"""
+  demo9_4 PROC:<{
+    DUP
+    -100 NEQINT
+    IFJMP:<{
+      0 GTINT
+      IFJMP:<{
+        t GETGLOB
+        123 PUSHINT
+        TPUSH
+        t SETGLOB
+      }>
+    }>
+    DROP
+  }>
+"""
+
+@fif_codegen
+"""
+  demo10_1 PROC:<{
+    DUP
+    0 EQINT
+    IFJMP:<{
+      DROP
+      t GETGLOB
+      123 PUSHINT
+      TPUSH
+      t SETGLOB
+    }>
+    1 EQINT
+    IFJMP:<{
+      t GETGLOB
+      456 PUSHINT
+      TPUSH
+      t SETGLOB
+    }>
+  }>
+"""
+
 */

tolk/pipe-ast-to-legacy.cpp

@@ -54,6 +54,7 @@ std::vector<var_idx_t> pre_compile_expr(AnyExprV v, CodeBlob& code, TypePtr targ
 std::vector<var_idx_t> pre_compile_symbol(SrcLocation loc, const Symbol* sym, CodeBlob& code, LValContext* lval_ctx);
 void process_any_statement(AnyV v, CodeBlob& code);
 
+static AnyV stmt_before_immediate_return = nullptr;
 
 // The goal of VarsModificationWatcher is to detect such cases: `return (x, x += y, x)`.
 // Without any changes, ops will be { _Call $2 = +($0_x, $1_y); _Return $0_x, $2, $0_x } - incorrect
@@ -1236,6 +1237,9 @@ static std::vector<var_idx_t> process_match_expression(V<ast_match_expression> v
     code.push_set_cur(if_op.block0);
     if (v->is_statement()) {
       pre_compile_expr(v_ith_arm->get_body(), code);
+      if (v == stmt_before_immediate_return) {
+        code.emplace_back(v_ith_arm->loc, Op::_Return);
+      }
     } else {
       std::vector<var_idx_t> arm_ir_idx = pre_compile_expr(v_ith_arm->get_body(), code, v->inferred_type);
       code.emplace_back(v->loc, Op::_Let, result_ir_idx, std::move(arm_ir_idx));
@@ -1249,6 +1253,9 @@ static std::vector<var_idx_t> process_match_expression(V<ast_match_expression> v
     auto v_last_arm = v->get_arm(n_arms - 1);
     if (v->is_statement()) {
       pre_compile_expr(v_last_arm->get_body(), code);
+      if (v == stmt_before_immediate_return) {
+        code.emplace_back(v_last_arm->loc, Op::_Return);
+      }
     } else {
       std::vector<var_idx_t> arm_ir_idx = pre_compile_expr(v_last_arm->get_body(), code, v->inferred_type);
       code.emplace_back(v->loc, Op::_Let, result_ir_idx, std::move(arm_ir_idx));
@@ -1743,9 +1750,30 @@ std::vector<var_idx_t> pre_compile_expr(AnyExprV v, CodeBlob& code, TypePtr targ
 
 
 static void process_block_statement(V<ast_block_statement> v, CodeBlob& code) {
-  for (AnyV item : v->get_items()) {
-    process_any_statement(item, code);
+  if (v->empty()) {
+    return;
   }
+
+  FunctionPtr cur_f = code.fun_ref;
+  bool does_f_return_nothing = cur_f->inferred_return_type == TypeDataVoid::create() && !cur_f->does_return_self() && !cur_f->has_mutate_params();
+  bool is_toplevel_block = v == cur_f->ast_root->as<ast_function_declaration>()->get_body();
+
+  // we want to optimize `match` and `if/else`: if it's the last statement, implicitly add "return" to every branch
+  // (to generate IFJMP instead of nested IF ELSE);
+  // a competent way is to do it at the IR level (building CST, etc.), it's impossible to tweak Ops for now;
+  // so, for every `f() { here }` of `... here; return;`, save it into a global, and handle within match/if
+  AnyV backup = stmt_before_immediate_return;
+  for (int i = 0; i < v->size() - 1; ++i) {
+    AnyV stmt = v->get_item(i);
+    AnyV next_stmt = v->get_item(i + 1);
+    bool next_is_empty_return = next_stmt->kind == ast_return_statement && !next_stmt->as<ast_return_statement>()->has_return_value();
+    stmt_before_immediate_return = next_is_empty_return && does_f_return_nothing ? stmt : nullptr;
+    process_any_statement(stmt, code);
+  }
+  AnyV last_stmt = v->get_item(v->size() - 1);
+  stmt_before_immediate_return = is_toplevel_block && does_f_return_nothing ? last_stmt : nullptr;
+  process_any_statement(last_stmt, code);
+  stmt_before_immediate_return = backup;
 }
 
 static void process_assert_statement(V<ast_assert_statement> v, CodeBlob& code) {
@@ -1817,9 +1845,15 @@ static void process_if_statement(V<ast_if_statement> v, CodeBlob& code) {
   Op& if_op = code.emplace_back(v->loc, Op::_If, std::move(cond));
   code.push_set_cur(if_op.block0);
   process_any_statement(v->get_if_body(), code);
+  if (v == stmt_before_immediate_return) {
+    code.emplace_back(v->get_if_body()->loc_end, Op::_Return);
+  }
   code.close_pop_cur(v->get_if_body()->loc_end);
   code.push_set_cur(if_op.block1);
   process_any_statement(v->get_else_body(), code);
+  if (v == stmt_before_immediate_return) {
+    code.emplace_back(v->get_else_body()->loc_end, Op::_Return);
+  }
   code.close_pop_cur(v->get_else_body()->loc_end);
   if (v->is_ifnot) {
     std::swap(if_op.block0, if_op.block1);
@@ -1978,9 +2012,7 @@ static void convert_function_body_to_CodeBlob(FunctionPtr fun_ref, FunctionBodyC
   blob->in_var_cnt = blob->var_cnt;
   tolk_assert(blob->var_cnt == total_arg_width);
 
-  for (AnyV item : v_body->get_items()) {
-    process_any_statement(item, *blob);
-  }
+  process_block_statement(v_body, *blob);
   append_implicit_return_statement(v_body->loc_end, *blob);
 
   blob->close_blk(v_body->loc_end);