invoke in mono

compiler/mono/src/tail_recursion.rs

@@ -90,6 +90,27 @@ fn insert_jumps<'a>(
             Some(arena.alloc(jump))
         }
 
+        Invoke {
+            symbol,
+            call:
+                crate::ir::Call {
+                    call_type: CallType::ByName { name: fsym, .. },
+                    arguments,
+                    ..
+                },
+            fail,
+            pass: Stmt::Ret(rsym),
+            ..
+        } if needle == *fsym && symbol == rsym => {
+            debug_assert_eq!(fail, &&Stmt::Unreachable);
+
+            // replace the call and return with a jump
+
+            let jump = Stmt::Jump(goal_id, arguments);
+
+            Some(arena.alloc(jump))
+        }
+
         Let(symbol, expr, layout, cont) => {
             let opt_cont = insert_jumps(arena, cont, goal_id, needle);
 
@@ -101,6 +122,35 @@ fn insert_jumps<'a>(
                 None
             }
         }
+
+        Invoke {
+            symbol,
+            call,
+            fail,
+            pass,
+            layout,
+        } => {
+            let opt_pass = insert_jumps(arena, pass, goal_id, needle);
+            let opt_fail = insert_jumps(arena, fail, goal_id, needle);
+
+            if opt_pass.is_some() || opt_fail.is_some() {
+                let pass = opt_pass.unwrap_or(pass);
+                let fail = opt_fail.unwrap_or(fail);
+
+                let stmt = Invoke {
+                    symbol: *symbol,
+                    call: call.clone(),
+                    layout: layout.clone(),
+                    pass,
+                    fail,
+                };
+
+                Some(arena.alloc(stmt))
+            } else {
+                None
+            }
+        }
+
         Join {
             id,
             parameters,