Treat metamethods as non-yieldable in table.sort and table.find

Author: HaroldCindy

VM/src/ltablib.cpp

@@ -422,7 +422,10 @@ static constexpr int SORT_YIELD_BUDGET = 512;
     else                                                                                         \
     {                                                                                            \
         int _sa = t->sizearray;                                                                  \
+        /* ServerLua: guard nCcalls so __lt metamethods can't yield from this context */          \
+        ++L->nCcalls;                                                                            \
         cmp_var = luaV_lessthan(L, &t->array[i_idx], &t->array[j_idx]);                         \
+        --L->nCcalls;                                                                            \
         if (t->sizearray != _sa)                                                                 \
             luaL_error(L, "table modified during sorting");                                      \
     }
@@ -819,7 +822,11 @@ DEFINE_YIELDABLE(tfind, 0)
 
         StkId v = L->base + 2;
 
-        if (equalobj(L, v, e))
+        // ServerLua: guard nCcalls so __eq metamethods can't yield from this context
+        ++L->nCcalls;
+        bool eq = equalobj(L, v, e);
+        --L->nCcalls;
+        if (eq)
         {
             lua_pushinteger(L, i);
             return 1;

tests/Conformance.test.cpp

@@ -1480,13 +1480,11 @@ TEST_CASE("StdlibYield")
         {
             if (pmTimingMode)
             {
-                if (gc >= 0 || gc == LUA_INTERRUPT_METAMETHOD)
+                // Skip GC interrupts and any non-yieldable context (e.g. inside
+                // a metamethod called from a yieldable function's nCcalls guard).
+                if (gc >= 0 || luaSL_may_interrupt(L) != YieldableStatus::OK)
                     return;
 
-                // All non-GC, non-metamethod interrupt points should be yieldable —
-                // validates the VM lets the scheduler preempt here.
-                LUAU_ASSERT(luaSL_may_interrupt(L) == YieldableStatus::OK);
-
                 double now = lua_cputime();
                 if (pmLastTimestamp > 0)
                 {

tests/conformance/stdlib_yield.lua

@@ -189,6 +189,27 @@ assert(not pcall(string.find, "a", string.rep("()", 33)))
 -- pattern too complex: 201 quantifiers exceed LUAI_MAXCCALLS (200) backtrack frames
 assert(not pcall(string.find, string.rep("a", 300), string.rep("a?", 201)))
 
+-- Yielding from __lt during default-comparator table.sort should error cleanly,
+-- not corrupt the CI stack. The nCcalls guard in SORT_CMP blocks the yield.
+assert(not pcall(function()
+  local mt = { __lt = function(a, b)
+    coroutine.yield()
+    return a[1] < b[1]
+  end }
+  local t = { setmetatable({2}, mt), setmetatable({1}, mt) }
+  table.sort(t)
+end))
+
+-- Same for __eq during table.find.
+assert(not pcall(function()
+  local mt = { __eq = function(a, b)
+    coroutine.yield()
+    return a[1] == b[1]
+  end }
+  local t = { setmetatable({1}, mt), setmetatable({2}, mt) }
+  table.find(t, setmetatable({2}, mt))
+end))
+
 -- Enable interrupt-driven yields from YIELD_CHECK for remaining tests.
 -- The interrupt handler (installed by C++ test fixture) calls lua_yield
 -- on every YIELD_CHECK hit, and we Ares round-trip on each yield.