fixes

Author: Vighnesh-V

definitions/task.luau

@@ -3,19 +3,23 @@ local time = require("./time")
 
 local task = {}
 
-function task.defer()
+function task.spawn<T..., U...>(routine: ((T...) -> U...) | thread, ...: T...): thread
 	error("unimplemented")
 end
 
-function task.wait(dur: (number | time.Duration)?): number
+function task.defer<T..., U...>(routine: ((T...) -> U...) | thread, ...: T...): thread
 	error("unimplemented")
 end
 
-function task.spawn<T..., U...>(routine: ((T...) -> U...) | thread, ...: T...): thread
+function task.resume(thread: thread): thread
 	error("unimplemented")
 end
 
-function task.resume(thread: thread): thread
+function task.deferSelf()
+	error("unimplemented")
+end
+
+function task.wait(dur: (number | time.Duration)?): number
 	error("unimplemented")
 end
 

examples/coroutine_error_isolation.luau

@@ -2,7 +2,7 @@ local task = require("@lute/task")
 
 local function loop()
 	while true do
-		task.defer()
+		task.deferSelf()
 
 		-- It may be useful to remove this print because it gets spammed, or implement another way
 		-- in which you can determinatively tell whether or not the thread is still active despite
@@ -13,7 +13,7 @@ end
 
 local function otherloop()
 	while true do
-		task.defer()
+		task.deferSelf()
 
 		if math.random(1, 2) == 1 then
 			error("oops")

lute/runtime/src/runtime.cpp

@@ -93,8 +93,6 @@ RuntimeStep Runtime::runOnce()
 
     int status = LUA_OK;
 
-    int co_status = lua_costatus(GL, L);
-
     // It's possible for a spawned task to be killed by a coroutine.close()
     // before it gets processed in the runningThreads queue. This leads to situations where a thread was scheduled to resume
     // but has already been killed.
@@ -108,7 +106,7 @@ RuntimeStep Runtime::runOnce()
     // 6) We can just step over it, because
     // a) if it scheduled a resume, the corresponding pending token will have been cleared
     // b) the corresponding ref for the lua state will be freed at the end of Runtime::runOnce()
-
+    int co_status = lua_costatus(GL, L);
     if (co_status == LUA_COFIN)
     {
         return StepSuccess{L};

lute/std/libs/task.luau

@@ -33,7 +33,7 @@ function tasklib.await(t: task): any
 	end
 
 	while t.success == nil do
-		task.defer()
+		task.deferSelf()
 	end
 
 	if t.success then
@@ -59,7 +59,7 @@ function tasklib.awaitall(...: task): ...unknown
 		for _, v in tasks do
 			if v.success == nil then
 				done = false
-				task.defer()
+				task.deferSelf()
 			end
 		end
 	end

lute/task/include/lute/task.h

@@ -12,19 +12,19 @@ namespace task
 {
 
 int lua_defer(lua_State* L);
+int lua_deferSelf(lua_State* L);
 int lua_wait(lua_State* L);
 int lua_spawn(lua_State* L);
 int lute_resume(lua_State* L);
 int lua_delay(lua_State* L);
 
 static const luaL_Reg lib[] = {
+    {"spawn", lua_spawn},
     {"defer", lua_defer},
+    {"resume", lute_resume},
+    {"deferSelf", lua_deferSelf},
     {"wait", lua_wait},
-    {"spawn", lua_spawn},
     {"delay", lua_delay},
-
-    {"resume", lute_resume},
-
     {nullptr, nullptr},
 };
 

lute/task/src/task.cpp

@@ -99,15 +99,15 @@ struct LuaThread
         , runtime(getRuntime(parent))
     {
         // At this point, the lua stack should look like:
-        // [function, (args...]
+        // [function, args...]
         // or
         // [thread, args...]
 
         // If passed a thread, we push the 0 or more arguments onto that threads stack and resume it.
         // If passed a function, we push the function and the 0 or more arguments onto a newly created thread's stack
         int toPush = lua_gettop(parent);
         // We only want to resume with the actual number of arguments here, regardless of if the first argument is a thread or a function
-        int numResumeArgs = numResumeArgs = toPush > 1 ? toPush - 1 : 0;
+        int numResumeArgs = toPush > 1 ? toPush - 1 : 0;
         if (!lua_checkstack(L, 1))
             luaL_error(L, "Not enough stack space to create a new thread");
         if (lua_isfunction(parent, 1))
@@ -188,14 +188,34 @@ int lua_spawn(lua_State* L)
     return newThread.resume();
 }
 
+int lua_deferSelf(lua_State* L)
+{
+
+    if (lua_gettop(L) != 0)
+    {
+        luaL_error(L, "task.deferSelf does not take any arguments");
+        return 0;
+    }
+    lua_pushthread(L);
+    LuaThread newThread{L};
+    newThread.defer();
+    return lua_yield(L, 0);
+}
+
 int lua_defer(lua_State* L)
 {
+
     LuaThread newThread{L};
     return newThread.defer();
 }
 
 int lute_resume(lua_State* L)
 {
+    if (!lua_isthread(L, 1))
+    {
+        luaL_error(L, "Expected a thread as the first argument.");
+        return 0;
+    }
     LuaThread newThread{L};
     return newThread.resume();
 }

tests/lute/task.test.luau

@@ -47,7 +47,7 @@ test.suite("LuteTaskSuite", function(suite)
 
 	-- task.spawn with function, >0 args
 	suite:case("taskSpawnFunctionWithArgsCoroutineStatus", function(assert)
-		local thread = task.spawn(function(a, b, c)
+		local thread = task.spawn(function(_a, _b, _c)
 			task.wait(2)
 		end, "hello", "world", "boom")
 
@@ -58,7 +58,7 @@ test.suite("LuteTaskSuite", function(suite)
 
 	-- task.spawn with thread, >0 args
 	suite:case("taskSpawnThreadWithArgsCoroutineStatus", function(assert)
-		local co = coroutine.create(function(a, b, c)
+		local co = coroutine.create(function(_a, _b, _c)
 			task.wait(2)
 		end)
 		local thread = task.spawn(co, "hello", "world", "boom")
@@ -93,7 +93,7 @@ test.suite("LuteTaskSuite", function(suite)
 
 	-- task.defer with function, >0 args
 	suite:case("taskDeferFunctionWithArgsCoroutineStatus", function(assert)
-		local thread = task.defer(function(a, b, c)
+		local thread = task.defer(function(_a, _b, _c)
 			task.wait(2)
 		end, "hello", "world", "boom")
 
@@ -104,7 +104,7 @@ test.suite("LuteTaskSuite", function(suite)
 
 	-- task.defer with thread, >0 args
 	suite:case("taskDeferThreadWithArgsCoroutineStatus", function(assert)
-		local co = coroutine.create(function(a, b, c)
+		local co = coroutine.create(function(_a, _b, _c)
 			task.wait(2)
 		end)
 		local thread = task.defer(co, "hello", "world", "boom")
@@ -128,7 +128,7 @@ test.suite("LuteTaskSuite", function(suite)
 
 	-- task.resume with thread, >0 args
 	suite:case("taskResumeThreadWithArgsCoroutineStatus", function(assert)
-		local co = coroutine.create(function(a, b, c)
+		local co = coroutine.create(function(_a, _b, _c)
 			task.wait(2)
 		end)
 		local thread = task.resume(co, "hello", "world", "boom")