Fix LUA_ERRKILL propagation with coroutine.resume()

Author: HaroldCindy

VM/src/lcorolib.cpp

@@ -72,6 +72,13 @@ static int auxresume(lua_State* L, lua_State* co, int narg)
     {
         return CO_STATUS_BREAK;
     }
+    else if (status == LUA_ERRKILL)
+    {
+        // ServerLua: Propagate uncatchable termination errors to parent thread
+        lua_xmove(co, L, 1); // move error message
+        lua_killerror(L, lua_tostring(L, -1)); // kill parent thread
+        // Never returns
+    }
     else
     {
         lua_xmove(co, L, 1); // move error message
@@ -101,6 +108,15 @@ static int auxresumecont(lua_State* L, lua_State* co)
     else
     {
         lua_rawcheckstack(L, 2);
+
+        // ServerLua: Propagate uncatchable termination errors to parent thread
+        if (co->status == LUA_ERRKILL)
+        {
+            lua_xmove(co, L, 1); // move error message
+            lua_killerror(L, lua_tostring(L, -1)); // kill parent thread
+            // Never returns
+        }
+
         lua_xmove(co, L, 1); // move error message
         return CO_STATUS_ERROR;
     }

VM/src/ldo.cpp

@@ -670,8 +670,7 @@ static int resume_finish(lua_State* L, int status)
 
     if (status != LUA_OK)
     {
-        // ServerLua: Set ERRRUN on thread for ERRKILL (both are terminal errors)
-        L->status = cast_byte(status == LUA_ERRKILL ? LUA_ERRRUN : status);
+        L->status = cast_byte(status);
 
         // ServerLua: Close upvalues for uncatchable termination errors
         if (status == LUA_ERRKILL)

tests/Conformance.test.cpp

@@ -3297,7 +3297,7 @@ TEST_CASE("KillError")
 
         interruptCount = 0;
         int status = lua_resume(T, nullptr, 0);
-        CHECK(status == LUA_ERRRUN);
+        CHECK(status == LUA_ERRKILL);
         CHECK(lua_isstring(T, -1));
         CHECK(std::string(lua_tostring(T, -1)).find("Script terminated") != std::string::npos);
 
@@ -3324,7 +3324,7 @@ TEST_CASE("KillError")
 
         interruptCount = 0;
         int status = lua_resume(T, nullptr, 0);
-        CHECK(status == LUA_ERRRUN);
+        CHECK(status == LUA_ERRKILL);
         CHECK(lua_isstring(T, -1));
         CHECK(std::string(lua_tostring(T, -1)).find("Script terminated") != std::string::npos);
 
@@ -3357,6 +3357,87 @@ TEST_CASE("KillError")
 
         lua_pop(L, 1);
     }
+
+    // lua_killerror propagates through coroutine.resume()
+    {
+        static int interruptCount;
+
+        lua_callbacks(L)->interrupt = [](lua_State* L, int gc)
+        {
+            if (gc >= 0)
+                return;
+            if (++interruptCount >= 10)
+            {
+                interruptCount = 0;
+                lua_killerror(L, "Script terminated in child");
+            }
+        };
+
+        lua_State* T = lua_newthread(L);
+        lua_getglobal(T, "testcoroutine");
+
+        interruptCount = 0;
+        int status = lua_resume(T, nullptr, 0);
+        CHECK(status == LUA_ERRKILL);
+        CHECK(lua_isstring(T, -1));
+        CHECK(std::string(lua_tostring(T, -1)).find("Script terminated in child") != std::string::npos);
+
+        lua_pop(L, 1);
+    }
+
+    // lua_killerror propagates through nested coroutines
+    {
+        static int interruptCount;
+
+        lua_callbacks(L)->interrupt = [](lua_State* L, int gc)
+        {
+            if (gc >= 0)
+                return;
+            if (++interruptCount >= 10)
+            {
+                interruptCount = 0;
+                lua_killerror(L, "Script terminated in nested child");
+            }
+        };
+
+        lua_State* T = lua_newthread(L);
+        lua_getglobal(T, "testnestedcoroutine");
+
+        interruptCount = 0;
+        int status = lua_resume(T, nullptr, 0);
+        CHECK(status == LUA_ERRKILL);
+        CHECK(lua_isstring(T, -1));
+        CHECK(std::string(lua_tostring(T, -1)).find("Script terminated in nested child") != std::string::npos);
+
+        lua_pop(L, 1);
+    }
+
+    // lua_killerror propagates through coroutine.wrap()
+    {
+        static int interruptCount;
+
+        lua_callbacks(L)->interrupt = [](lua_State* L, int gc)
+        {
+            if (gc >= 0)
+                return;
+            if (++interruptCount >= 10)
+            {
+                interruptCount = 0;
+                lua_killerror(L, "Script terminated in wrapped coroutine");
+            }
+        };
+
+        lua_State* T = lua_newthread(L);
+        lua_getglobal(T, "testwrap");
+
+        interruptCount = 0;
+        int status = lua_resume(T, nullptr, 0);
+        CHECK(status == LUA_ERRKILL);
+        CHECK(lua_isstring(T, -1));
+        CHECK(std::string(lua_tostring(T, -1)).find("Script terminated in wrapped coroutine") != std::string::npos);
+
+        lua_pop(L, 1);
+    }
 }
 
 TEST_CASE("UserdataApi")

tests/conformance/killerror.lua

@@ -30,4 +30,30 @@ function testnested()
     error("should not reach here")
 end
 
+-- Test coroutine.resume() with infinite loop in child
+function testcoroutine()
+    local co = coroutine.create(infiniteloop)
+    local success, err = coroutine.resume(co)
+    -- Should never reach here - kill should propagate to parent
+    error("should not reach here")
+end
+
+-- Test nested coroutines with infinite loop
+function testnestedcoroutine()
+    local inner = coroutine.create(infiniteloop)
+    local outer = coroutine.create(function()
+        coroutine.resume(inner)
+        error("should not reach here")
+    end)
+    coroutine.resume(outer)
+    error("should not reach here")
+end
+
+-- Test coroutine.wrap() with infinite loop
+function testwrap()
+    local f = coroutine.wrap(infiniteloop)
+    f()
+    error("should not reach here")
+end
+
 return "OK"