Panics can be caught from TCO loops

engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/error/CatchPanicNode.java

@@ -38,6 +38,7 @@ public abstract class CatchPanicNode extends Node {
             new CallArgumentInfo[] {new CallArgumentInfo()},
             InvokeCallableNode.DefaultsExecutionMode.EXECUTE,
             InvokeCallableNode.ArgumentsExecutionMode.PRE_EXECUTED);
+    // Note [Tail call]
     this.invokeCallableNode.setTailStatus(BaseNode.TailStatus.TAIL_DIRECT);
   }
 
@@ -59,7 +60,8 @@ Object doExecute(
       @Cached BranchProfile otherExceptionBranchProfile,
       @CachedLibrary(limit = "3") InteropLibrary interop) {
     try {
-      return thunkExecutorNode.executeThunk(frame, action, state, BaseNode.TailStatus.TAIL_DIRECT);
+      // Note [Tail call]
+      return thunkExecutorNode.executeThunk(frame, action, state, BaseNode.TailStatus.NOT_TAIL);
     } catch (PanicException e) {
       panicBranchProfile.enter();
       Object payload = e.getPayload();
@@ -93,4 +95,14 @@ private Object executeCallbackOrRethrow(
       }
     }
   }
+
+  /* Note [Tail call]
+   * ~~~~~~~~~~~~~~~~~~~~~~
+   * The `NOT_TAIL` in `isTail` parameter is important here. Panic.catch cannot be in
+   * the tail call position. If it is, the panic may not be caught when a tail-call-optimized
+   * thunk is evaluated (as that will effectively discard this method call from the stack).
+   *
+   * This is important for the `action` parameter of `Panic.catch`. The `handler` callback can
+   * be executed as tail, as there is nothing in this class that needs to run after the `handler`.
+   */
 }

test/Base_Tests/src/Semantic/Error_Spec.enso

@@ -44,6 +44,14 @@ foreign js throw_js_str = """
 foreign js throw_js_arr = """
     throw [1,2,3];
 
+fn_with_tco x =
+    if x == 1 then Panic.throw "fn_with_tco" else
+        @Tail_Call fn_with_tco x+1
+
+global_wrapper_fn =
+    fn_with_tco 0
+
+
 add_specs suite_builder =
     suite_builder.group "No Method Errors" group_builder->
         group_builder.specify "should be recoverable" <|
@@ -361,6 +369,41 @@ add_specs suite_builder =
             c2 . should_equal "finalizer"
             v2.to_vector . should_equal [1, 2]
 
+        group_builder.specify "should be caught in a loop" <|
+            fn_without_tco x =
+                if x == 1 then Panic.throw "fn_without_tco" else
+                    fn_without_tco x+1
+
+            p = Panic.catch Any handler=(.payload) <| fn_without_tco 0
+            p . should_equal "fn_without_tco"
+
+        group_builder.specify "should be caught in a TCO loop" <|
+            fn_with_tco x =
+                if x == 1 then Panic.throw "fn_with_tco" else
+                    @Tail_Call fn_with_tco x+1
+
+            p = Panic.catch Any handler=(.payload) <| fn_with_tco 0
+            p . should_equal "fn_with_tco"
+
+        # The same test as the one before, but it does not use the `<|` function.
+        group_builder.specify "should be caught in a TCO loop with a wrapper fn" <|
+            fn_with_tco x =
+                if x == 1 then Panic.throw "fn_with_tco" else
+                    @Tail_Call fn_with_tco x+1
+
+            wrapper_fn =
+                fn_with_tco 0
+
+            p = Panic.catch Any handler=(.payload) wrapper_fn
+            p . should_equal "fn_with_tco"
+
+        # The same test as the above one, but calls a global wrapper_fn that is declared
+        # in top scope.
+        group_builder.specify "should be caught in a TCO loop with a global wrapper fn" <|
+            p = Panic.catch Any handler=(.payload) global_wrapper_fn
+            p . should_equal "fn_with_tco"
+
+
     suite_builder.group "Type Errors" group_builder->
         my_func x y =
             x + y