fix: ensure 'trap' keyword intercepts only panics occurring after its invocation. Allow pre-existing panic states to propagate when 'trap' is used in defer functions

Author: jacopodl

argon/vm/areval.cpp

@@ -1425,6 +1425,9 @@ ArObject *argon::vm::Eval(Fiber *fiber) {
             }
             TARGET_OP(ST) {
                 cu_frame->trap_ptr = JUMPADDR(I32Arg(cu_frame->instr_ptr));
+
+                cu_frame->panic_baseline = (void *) fiber->panic;
+
                 DISPATCH4();
             }
             TARGET_OP(STATTR) {
@@ -1554,14 +1557,15 @@ ArObject *argon::vm::Eval(Fiber *fiber) {
             }
             TARGET_OP(TRAP) {
                 auto handler = I32Arg(cu_frame->instr_ptr);
-                ArObject *tmp = GetLastError();
+                ArObject *tmp = TrapPanic(fiber, cu_frame);
 
                 cu_frame->trap_ptr = handler > 0 ? JUMPADDR(handler) : nullptr;
 
-                if (tmp == nullptr)
-                    ret = (ArObject *) ResultNew(TOP(), true);
-                else
-                    ret = (ArObject *) ResultNew(tmp, false);
+                if (handler == 0)
+                    cu_frame->panic_baseline = nullptr;
+
+                ret = (ArObject *) (tmp == nullptr ? ResultNew(TOP(), true)
+                                                   : ResultNew(tmp, false));
 
                 Release(tmp);
 

argon/vm/frame.h

@@ -42,6 +42,9 @@ namespace argon::vm {
         /// Pointer to the code trap handler for this frame.
         unsigned char *trap_ptr;
 
+        /// Pointer to panic state(if any).
+        void *panic_baseline;
+
         /// Evaluation stack.
         datatype::ArObject **eval_stack;
 

argon/vm/runtime.cpp

@@ -698,6 +698,44 @@ ArObject *argon::vm::GetLastError() {
     return error;
 }
 
+ArObject *argon::vm::TrapPanic(Fiber *fiber, const Frame *frame) {
+    ArObject *error = nullptr;
+
+    struct Panic *expected = nullptr;
+
+    if (fiber == nullptr || frame == nullptr || fiber->panic == nullptr)
+        return nullptr;
+
+    const auto *baseline = frame->panic_baseline;
+    auto oom_check = false;
+
+    auto *tmp = fiber->panic;
+    for (auto *cursor = fiber->panic; cursor != nullptr && cursor != baseline; cursor = tmp) {
+        tmp = cursor->panic;
+
+        if (error == nullptr)
+            error = cursor->object;
+
+        FrameDelRec(cursor->frame);
+
+        if (!oom_check) {
+            if (panic_oom.compare_exchange_strong(expected, cursor)) {
+                oom_check = true;
+                continue;
+            }
+        }
+
+        memory::Free(cursor);
+    }
+
+    if (tmp != nullptr)
+        tmp->aborted = false;
+
+    fiber->panic = tmp;
+
+    return error;
+}
+
 Future *argon::vm::EvalAsync(Context *context, datatype::Function *func, datatype::ArObject **argv,
                              datatype::ArSize argc, argon::vm::OpCodeCallMode mode) {
     auto *fiber = AllocFiber(context);

argon/vm/runtime.h

@@ -34,6 +34,8 @@ namespace argon::vm {
 
     argon::vm::datatype::ArObject *GetLastError();
 
+    argon::vm::datatype::ArObject *TrapPanic(Fiber *fiber, const Frame *frame);
+
     argon::vm::datatype::Future *EvalAsync(Context *context,
                                            datatype::Function *func,
                                            datatype::ArObject **argv,