Experiment with automatic async function wrapping;

Author: bjornbytes

src/api/api.c

@@ -314,6 +314,33 @@ void luax_registerloader(lua_State* L, lua_CFunction loader, int index) {
   lua_pop(L, 1);
 }
 
+static int luax_wrapasync(lua_State* L) {
+  if (luax_gettask(L)) {
+    int n = lua_gettop(L);
+    lua_pushvalue(L, lua_upvalueindex(1));
+    lua_insert(L, 1);
+    return luax_callthread(L, n);
+  } else {
+    lua_CFunction function = lua_tocfunction(L, lua_upvalueindex(1));
+    return function(L);
+  }
+}
+
+void _luax_registerasync(lua_State* L, const char* name, const char** methods) {
+  luaL_getmetatable(L, name);
+
+  if (lua_istable(L, -1)) {
+    while (*methods) {
+      const char* method = *methods++;
+      lua_getfield(L, -1, method);
+      lua_pushcclosure(L, luax_wrapasync, 1);
+      lua_setfield(L, -2, method);
+    }
+  }
+
+  lua_pop(L, 1);
+}
+
 int luax_resume(lua_State* T, int n) {
 #if LUA_VERSION_NUM >= 504
   int results;

src/api/api.h

@@ -104,6 +104,7 @@ typedef struct {
 #endif
 
 #define luax_registertype(L, T) _luax_registertype(L, T_ ## T, #T, lovr ## T ## Destroy, lovr ## T)
+#define luax_registerasync(L, T) _luax_registerasync(L, #T, lovr ## T ## Async)
 #define luax_totype(L, i, T) (T*) _luax_totype(L, i, T_ ## T)
 #define luax_checktype(L, i, T) (T*) _luax_checktype(L, i, T_ ## T)
 #define luax_pushtype(L, T, o) _luax_pushtype(L, T_ ## T, o)
@@ -124,6 +125,7 @@ int luax_typeerror(lua_State* L, int index, const char* expected);
 void _luax_pushtype(lua_State* L, int type, void* object);
 int _luax_checkenum(lua_State* L, int index, const StringEntry* map, const char* fallback, const char* label);
 void luax_registerloader(lua_State* L, int (*loader)(lua_State* L), int index);
+void _luax_registerasync(lua_State* L, const char* type, const char** methods);
 int luax_resume(lua_State* T, int n);
 int luax_loadbufferx(lua_State* L, const char* buffer, size_t size, const char* name, const char* mode);
 void luax_vthrow(void* L, const char* format, va_list args);
@@ -205,5 +207,10 @@ struct Shape* luax_newterrainshape(lua_State* L, int index);
 
 #ifndef LOVR_DISABLE_TASK
 #include "task/task.h"
+Task* luax_gettask(lua_State* L);
 int luax_runasync(lua_State* L, fn_task* fn, fn_continuation* continuation, void* context);
 #endif
+
+#ifndef LOVR_DISABLE_THREAD
+int luax_callthread(lua_State* L, int n);
+#endif

src/api/l_physics.c

@@ -343,6 +343,8 @@ extern const luaL_Reg lovrDistanceJoint[];
 extern const luaL_Reg lovrHingeJoint[];
 extern const luaL_Reg lovrSliderJoint[];
 
+extern const char* lovrWorldAsync[];
+
 static void luax_unref(void* object, uintptr_t userdata) {
   if (!userdata) return;
   lua_State* L = (lua_State*) userdata;
@@ -370,6 +372,7 @@ int luaopen_lovr_physics(lua_State* L) {
   luax_registertype(L, DistanceJoint);
   luax_registertype(L, HingeJoint);
   luax_registertype(L, SliderJoint);
+  luax_registerasync(L, World);
   lovrPhysicsInit(luax_unref);
   luax_atexit(L, lovrPhysicsDestroy);
   return 1;

src/api/l_physics_world.c

@@ -708,3 +708,8 @@ const luaL_Reg lovrWorld[] = {
 
   { NULL, NULL }
 };
+
+const char* lovrWorldAsync[] = {
+  "raycast",
+  NULL
+};

src/api/l_task.c

@@ -5,7 +5,7 @@
 #include <stdlib.h>
 #include <string.h>
 
-static Task* luax_gettask(lua_State* L) {
+Task* luax_gettask(lua_State* L) {
   lua_getfield(L, LUA_REGISTRYINDEX, "_lovrtasks");
   if (lua_isnil(L, -1)) return lua_pop(L, 1), NULL;
   lua_pushthread(L);

src/api/l_thread.c

@@ -210,7 +210,7 @@ static int writer(lua_State* L, const void* data, size_t size, void* userdata) {
   return 0;
 }
 
-static int l_lovrThreadRun(lua_State* L) {
+int luax_callthread(lua_State* L, int n) {
   RunContext* context = contextPool;
 
   if (context) {
@@ -225,16 +225,18 @@ static int l_lovrThreadRun(lua_State* L) {
     arr_init(&context->code);
   }
 
-  if (lua_iscfunction(L, 1)) {
-    context->function = lua_tocfunction(L, 1);
+  int function = lua_gettop(L) - n;
+
+  if (lua_iscfunction(L, function)) {
+    context->function = lua_tocfunction(L, function);
   } else {
-    luaL_checktype(L, 1, LUA_TFUNCTION);
+    luaL_checktype(L, function, LUA_TFUNCTION);
     lua_getfield(L, LUA_REGISTRYINDEX, "_lovrbytecode");
-    lua_pushvalue(L, 1);
+    lua_pushvalue(L, function);
     lua_rawget(L, -2);
 
     if (lua_isnil(L, -1)) {
-      lua_pushvalue(L, 1);
+      lua_pushvalue(L, function);
       luax_check(L, !lua_dump(L, writer, context), "Failed to dump function to bytecode");
       lua_pushlstring(L, context->code.data, context->code.length);
       lua_rawset(L, -4);
@@ -247,8 +249,6 @@ static int l_lovrThreadRun(lua_State* L) {
     }
   }
 
-  int n = lua_gettop(L) - 1;
-
   if (n > 0) {
     context->argumentCount = n;
     context->arguments = lovrMalloc(n * sizeof(Variant));
@@ -260,6 +260,10 @@ static int l_lovrThreadRun(lua_State* L) {
   return luax_runasync(L, luax_runlua, luax_pushresults, context);
 }
 
+static int l_lovrThreadRun(lua_State* L) {
+  return luax_callthread(L, lua_gettop(L) - 1);
+}
+
 static const luaL_Reg lovrThreadModule[] = {
   { "newThread", l_lovrThreadNewThread },
   { "newChannel", l_lovrThreadNewChannel },