Merge remote-tracking branch 'upstream/master' into rahm

1 files changed, 728 insertions, 170 deletions

diff --git a/src/nvim/lua/executor.c b/src/nvim/lua/executor.c
index cfdbe7b344..ad03ebd1ed 100644
--- a/src/nvim/lua/executor.c
+++ b/src/nvim/lua/executor.c
@@ -4,6 +4,7 @@
 #include <lauxlib.h>
 #include <lua.h>
 #include <lualib.h>
+#include <tree_sitter/api.h>
 
 #include "luv/luv.h"
 #include "nvim/api/private/defs.h"
@@ -14,6 +15,7 @@
 #include "nvim/buffer_defs.h"
 #include "nvim/change.h"
 #include "nvim/cursor.h"
+#include "nvim/eval/typval.h"
 #include "nvim/eval/userfunc.h"
 #include "nvim/event/loop.h"
 #include "nvim/event/time.h"
@@ -34,21 +36,33 @@
 #include "nvim/message.h"
 #include "nvim/msgpack_rpc/channel.h"
 #include "nvim/os/os.h"
+#include "nvim/profile.h"
 #include "nvim/screen.h"
 #include "nvim/undo.h"
 #include "nvim/version.h"
 #include "nvim/vim.h"
+#include "nvim/window.h"
 
 static int in_fast_callback = 0;
 
 // Initialized in nlua_init().
 static lua_State *global_lstate = NULL;
 
+static LuaRef require_ref = LUA_REFNIL;
+
+static uv_thread_t main_thread;
+
 typedef struct {
   Error err;
   String lua_err_str;
 } LuaError;
 
+typedef struct {
+  char *name;
+  const uint8_t *data;
+  size_t size;
+} ModuleDef;
+
 #ifdef INCLUDE_GENERATED_DECLARATIONS
 # include "lua/executor.c.generated.h"
 # include "lua/vim_module.generated.h"
@@ -64,11 +78,16 @@ typedef struct {
   }
 
 #if __has_feature(address_sanitizer)
-static PMap(handle_T) nlua_ref_markers = MAP_INIT;
 static bool nlua_track_refs = false;
 # define NLUA_TRACK_REFS
 #endif
 
+typedef enum luv_err_type {
+  kCallback,
+  kThread,
+  kThreadCallback,
+} luv_err_t;
+
 /// Convert lua error into a Vim error message
 ///
 /// @param  lstate  Lua interpreter state.
@@ -77,7 +96,22 @@ static void nlua_error(lua_State *const lstate, const char *const msg)
   FUNC_ATTR_NONNULL_ALL
 {
   size_t len;
-  const char *const str = lua_tolstring(lstate, -1, &len);
+  const char *str = NULL;
+
+  if (luaL_getmetafield(lstate, -1, "__tostring")) {
+    if (lua_isfunction(lstate, -1) && luaL_callmeta(lstate, -2, "__tostring")) {
+      // call __tostring, convert the result and pop result.
+      str = lua_tolstring(lstate, -1, &len);
+      lua_pop(lstate, 1);
+    }
+    // pop __tostring.
+    lua_pop(lstate, 1);
+  }
+
+  if (!str) {
+    // defer to lua default conversion, this will render tables as [NULL].
+    str = lua_tolstring(lstate, -1, &len);
+  }
 
   msg_ext_set_kind("lua_error");
   semsg_multiline(msg, (int)len, str);
@@ -105,7 +139,6 @@ static int nlua_pcall(lua_State *lstate, int nargs, int nresults)
   return status;
 }
 
-
 /// Gets the version of the current Nvim build.
 ///
 /// @param  lstate  Lua interpreter state.
@@ -117,12 +150,24 @@ static int nlua_nvim_version(lua_State *const lstate) FUNC_ATTR_NONNULL_ALL
   return 1;
 }
 
-
 static void nlua_luv_error_event(void **argv)
 {
   char *error = (char *)argv[0];
+  luv_err_t type = (luv_err_t)(intptr_t)argv[1];
   msg_ext_set_kind("lua_error");
-  semsg_multiline("Error executing luv callback:\n%s", error);
+  switch (type) {
+  case kCallback:
+    semsg_multiline("Error executing luv callback:\n%s", error);
+    break;
+  case kThread:
+    semsg_multiline("Error in luv thread:\n%s", error);
+    break;
+  case kThreadCallback:
+    semsg_multiline("Error in luv callback, thread:\n%s", error);
+    break;
+  default:
+    break;
+  }
   xfree(error);
 }
 
@@ -147,7 +192,7 @@ static int nlua_luv_cfpcall(lua_State *lstate, int nargs, int nresult, int flags
     const char *error = lua_tostring(lstate, -1);
 
     multiqueue_put(main_loop.events, nlua_luv_error_event,
-                   1, xstrdup(error));
+                   2, xstrdup(error), (intptr_t)kCallback);
     lua_pop(lstate, 1);  // error message
     retval = -status;
   } else {  // LUA_OK
@@ -161,12 +206,109 @@ static int nlua_luv_cfpcall(lua_State *lstate, int nargs, int nresult, int flags
   return retval;
 }
 
+static int nlua_luv_thread_cb_cfpcall(lua_State *lstate, int nargs, int nresult, int flags)
+{
+  return nlua_luv_thread_common_cfpcall(lstate, nargs, nresult, flags, true);
+}
+
+static int nlua_luv_thread_cfpcall(lua_State *lstate, int nargs, int nresult, int flags)
+  FUNC_ATTR_NONNULL_ALL
+{
+  return nlua_luv_thread_common_cfpcall(lstate, nargs, nresult, flags, false);
+}
+
+static int nlua_luv_thread_cfcpcall(lua_State *lstate, lua_CFunction func, void *ud, int flags)
+  FUNC_ATTR_NONNULL_ARG(1, 2)
+{
+  lua_pushcfunction(lstate, func);
+  lua_pushlightuserdata(lstate, ud);
+  int retval = nlua_luv_thread_cfpcall(lstate, 1, 0, flags);
+  return retval;
+}
+
+static int nlua_luv_thread_common_cfpcall(lua_State *lstate, int nargs, int nresult, int flags,
+                                          bool is_callback)
+  FUNC_ATTR_NONNULL_ALL
+{
+  int retval;
+
+  int top = lua_gettop(lstate);
+  int status = lua_pcall(lstate, nargs, nresult, 0);
+  if (status) {
+    if (status == LUA_ERRMEM && !(flags & LUVF_CALLBACK_NOEXIT)) {
+      // Terminate this thread, as the main thread may be able to continue
+      // execution.
+      mch_errmsg(e_outofmem);
+      mch_errmsg("\n");
+      lua_close(lstate);
+#ifdef WIN32
+      ExitThread(0);
+#else
+      pthread_exit(0);
+#endif
+    }
+    const char *error = lua_tostring(lstate, -1);
+
+    loop_schedule_deferred(&main_loop,
+                           event_create(nlua_luv_error_event, 2,
+                                        xstrdup(error),
+                                        is_callback
+                                        ? (intptr_t)kThreadCallback
+                                        : (intptr_t)kThread));
+    lua_pop(lstate, 1);  // error message
+    retval = -status;
+  } else {  // LUA_OK
+    if (nresult == LUA_MULTRET) {
+      nresult = lua_gettop(lstate) - top + nargs + 1;
+    }
+    retval = nresult;
+  }
+
+  return retval;
+}
+
+static int nlua_thr_api_nvim__get_runtime(lua_State *lstate)
+{
+  if (lua_gettop(lstate) != 3) {
+    return luaL_error(lstate, "Expected 3 arguments");
+  }
+
+  luaL_checktype(lstate, -1, LUA_TTABLE);
+  lua_getfield(lstate, -1, "is_lua");
+  if (!lua_isboolean(lstate, -1)) {
+    return luaL_error(lstate, "is_lua is not a boolean");
+  }
+  bool is_lua = lua_toboolean(lstate, -1);
+  lua_pop(lstate, 2);
+
+  luaL_checktype(lstate, -1, LUA_TBOOLEAN);
+  bool all = lua_toboolean(lstate, -1);
+  lua_pop(lstate, 1);
+
+  Error err = ERROR_INIT;
+  const Array pat = nlua_pop_Array(lstate, &err);
+  if (ERROR_SET(&err)) {
+    luaL_where(lstate, 1);
+    lua_pushstring(lstate, err.msg);
+    api_clear_error(&err);
+    lua_concat(lstate, 2);
+    return lua_error(lstate);
+  }
+
+  ArrayOf(String) ret = runtime_get_named_thread(is_lua, pat, all);
+  nlua_push_Array(lstate, ret, true);
+  api_free_array(ret);
+  api_free_array(pat);
+
+  return 1;
+}
+
 static void nlua_schedule_event(void **argv)
 {
   LuaRef cb = (LuaRef)(ptrdiff_t)argv[0];
   lua_State *const lstate = global_lstate;
   nlua_pushref(lstate, cb);
-  nlua_unref(lstate, cb);
+  nlua_unref_global(lstate, cb);
   if (nlua_pcall(lstate, 0, 0)) {
     nlua_error(lstate, _("Error executing vim.schedule lua callback: %.*s"));
   }
@@ -183,7 +325,7 @@ static int nlua_schedule(lua_State *const lstate)
     return lua_error(lstate);
   }
 
-  LuaRef cb = nlua_ref(lstate, 1);
+  LuaRef cb = nlua_ref_global(lstate, 1);
 
   multiqueue_put(main_loop.events, nlua_schedule_event,
                  1, (void *)(ptrdiff_t)cb);
@@ -192,8 +334,7 @@ static int nlua_schedule(lua_State *const lstate)
 
 // Dummy timer callback. Used by f_wait().
 static void dummy_timer_due_cb(TimeWatcher *tw, void *data)
-{
-}
+{}
 
 // Dummy timer close callback. Used by f_wait().
 static void dummy_timer_close_cb(TimeWatcher *tw, void *data)
@@ -219,7 +360,7 @@ static int nlua_wait(lua_State *lstate)
 {
   intptr_t timeout = luaL_checkinteger(lstate, 1);
   if (timeout < 0) {
-    return luaL_error(lstate, "timeout must be > 0");
+    return luaL_error(lstate, "timeout must be >= 0");
   }
 
   int lua_top = lua_gettop(lstate);
@@ -246,7 +387,7 @@ static int nlua_wait(lua_State *lstate)
   if (lua_top >= 3 && !lua_isnil(lstate, 3)) {
     interval = luaL_checkinteger(lstate, 3);
     if (interval < 0) {
-      return luaL_error(lstate, "interval must be > 0");
+      return luaL_error(lstate, "interval must be >= 0");
     }
   }
 
@@ -301,10 +442,154 @@ static int nlua_wait(lua_State *lstate)
   return 2;
 }
 
+static nlua_ref_state_t *nlua_new_ref_state(lua_State *lstate, bool is_thread)
+  FUNC_ATTR_NONNULL_ALL
+{
+  nlua_ref_state_t *ref_state = lua_newuserdata(lstate, sizeof(*ref_state));
+  memset(ref_state, 0, sizeof(*ref_state));
+  ref_state->nil_ref = LUA_NOREF;
+  ref_state->empty_dict_ref = LUA_NOREF;
+  if (!is_thread) {
+    nlua_global_refs = ref_state;
+  }
+  return ref_state;
+}
+
+static nlua_ref_state_t *nlua_get_ref_state(lua_State *lstate)
+  FUNC_ATTR_NONNULL_ALL
+{
+  lua_getfield(lstate, LUA_REGISTRYINDEX, "nlua.ref_state");
+  nlua_ref_state_t *ref_state = lua_touserdata(lstate, -1);
+  lua_pop(lstate, 1);
+
+  return ref_state;
+}
+
+LuaRef nlua_get_nil_ref(lua_State *lstate)
+  FUNC_ATTR_NONNULL_ALL
+{
+  nlua_ref_state_t *ref_state = nlua_get_ref_state(lstate);
+  return ref_state->nil_ref;
+}
+
+LuaRef nlua_get_empty_dict_ref(lua_State *lstate)
+  FUNC_ATTR_NONNULL_ALL
+{
+  nlua_ref_state_t *ref_state = nlua_get_ref_state(lstate);
+  return ref_state->empty_dict_ref;
+}
+
+int nlua_get_global_ref_count(void)
+{
+  return nlua_global_refs->ref_count;
+}
+
+static void nlua_common_vim_init(lua_State *lstate, bool is_thread)
+  FUNC_ATTR_NONNULL_ARG(1)
+{
+  nlua_ref_state_t *ref_state = nlua_new_ref_state(lstate, is_thread);
+  lua_setfield(lstate, LUA_REGISTRYINDEX, "nlua.ref_state");
+
+  // vim.is_thread
+  lua_pushboolean(lstate, is_thread);
+  lua_setfield(lstate, LUA_REGISTRYINDEX, "nvim.thread");
+  lua_pushcfunction(lstate, &nlua_is_thread);
+  lua_setfield(lstate, -2, "is_thread");
+
+  // vim.NIL
+  lua_newuserdata(lstate, 0);
+  lua_createtable(lstate, 0, 0);
+  lua_pushcfunction(lstate, &nlua_nil_tostring);
+  lua_setfield(lstate, -2, "__tostring");
+  lua_setmetatable(lstate, -2);
+  ref_state->nil_ref = nlua_ref(lstate,  ref_state, -1);
+  lua_pushvalue(lstate, -1);
+  lua_setfield(lstate, LUA_REGISTRYINDEX, "mpack.NIL");
+  lua_setfield(lstate, -2, "NIL");
+
+  // vim._empty_dict_mt
+  lua_createtable(lstate, 0, 0);
+  lua_pushcfunction(lstate, &nlua_empty_dict_tostring);
+  lua_setfield(lstate, -2, "__tostring");
+  ref_state->empty_dict_ref = nlua_ref(lstate, ref_state, -1);
+  lua_pushvalue(lstate, -1);
+  lua_setfield(lstate, LUA_REGISTRYINDEX, "mpack.empty_dict");
+  lua_setfield(lstate, -2, "_empty_dict_mt");
+
+  // vim.loop
+  if (is_thread) {
+    luv_set_callback(lstate, nlua_luv_thread_cb_cfpcall);
+    luv_set_thread(lstate, nlua_luv_thread_cfpcall);
+    luv_set_cthread(lstate, nlua_luv_thread_cfcpcall);
+  } else {
+    luv_set_loop(lstate, &main_loop.uv);
+    luv_set_callback(lstate, nlua_luv_cfpcall);
+  }
+  luaopen_luv(lstate);
+  lua_pushvalue(lstate, -1);
+  lua_setfield(lstate, -3, "loop");
+
+  // package.loaded.luv = vim.loop
+  // otherwise luv will be reinitialized when require'luv'
+  lua_getglobal(lstate, "package");
+  lua_getfield(lstate, -1, "loaded");
+  lua_pushvalue(lstate, -3);
+  lua_setfield(lstate, -2, "luv");
+  lua_pop(lstate, 3);
+}
+
+static int nlua_module_preloader(lua_State *lstate)
+{
+  size_t i = (size_t)lua_tointeger(lstate, lua_upvalueindex(1));
+  ModuleDef def = builtin_modules[i];
+  char name[256];
+  name[0] = '@';
+  size_t off = xstrlcpy(name + 1, def.name, (sizeof name) - 2);
+  strchrsub(name + 1, '.', '/');
+  xstrlcpy(name + 1 + off, ".lua", (sizeof name) - 2 - off);
+
+  if (luaL_loadbuffer(lstate, (const char *)def.data, def.size - 1, name)) {
+    return lua_error(lstate);
+  }
+
+  lua_call(lstate, 0, 1);  // propagates error to caller
+  return 1;
+}
+
+static bool nlua_init_packages(lua_State *lstate)
+  FUNC_ATTR_NONNULL_ALL
+{
+  // put builtin packages in preload
+  lua_getglobal(lstate, "package");  // [package]
+  lua_getfield(lstate, -1, "preload");  // [package, preload]
+  for (size_t i = 0; i < ARRAY_SIZE(builtin_modules); i++) {
+    ModuleDef def = builtin_modules[i];
+    lua_pushinteger(lstate, (long)i);  // [package, preload, i]
+    lua_pushcclosure(lstate, nlua_module_preloader, 1);  // [package, preload, cclosure]
+    lua_setfield(lstate, -2, def.name);  // [package, preload]
+
+    if (nlua_disable_preload && strequal(def.name, "vim.inspect")) {
+      break;
+    }
+  }
+
+  lua_pop(lstate, 2);  // []
+
+  lua_getglobal(lstate, "require");
+  lua_pushstring(lstate, "vim._init_packages");
+  if (nlua_pcall(lstate, 1, 0)) {
+    mch_errmsg(lua_tostring(lstate, -1));
+    mch_errmsg("\n");
+    return false;
+  }
+
+  return true;
+}
+
 /// Initialize lua interpreter state
 ///
 /// Called by lua interpreter itself to initialize state.
-static int nlua_state_init(lua_State *const lstate) FUNC_ATTR_NONNULL_ALL
+static bool nlua_state_init(lua_State *const lstate) FUNC_ATTR_NONNULL_ALL
 {
   // print
   lua_pushcfunction(lstate, &nlua_print);
@@ -361,117 +646,30 @@ static int nlua_state_init(lua_State *const lstate) FUNC_ATTR_NONNULL_ALL
   lua_pushcfunction(lstate, &nlua_wait);
   lua_setfield(lstate, -2, "wait");
 
-  // vim.NIL
-  lua_newuserdata(lstate, 0);
-  lua_createtable(lstate, 0, 0);
-  lua_pushcfunction(lstate, &nlua_nil_tostring);
-  lua_setfield(lstate, -2, "__tostring");
-  lua_setmetatable(lstate, -2);
-  nlua_nil_ref = nlua_ref(lstate, -1);
-  lua_pushvalue(lstate, -1);
-  lua_setfield(lstate, LUA_REGISTRYINDEX, "mpack.NIL");
-  lua_setfield(lstate, -2, "NIL");
+  nlua_common_vim_init(lstate, false);
 
-  // vim._empty_dict_mt
-  lua_createtable(lstate, 0, 0);
-  lua_pushcfunction(lstate, &nlua_empty_dict_tostring);
-  lua_setfield(lstate, -2, "__tostring");
-  nlua_empty_dict_ref = nlua_ref(lstate, -1);
-  lua_pushvalue(lstate, -1);
-  lua_setfield(lstate, LUA_REGISTRYINDEX, "mpack.empty_dict");
-  lua_setfield(lstate, -2, "_empty_dict_mt");
+  // patch require() (only for --startuptime)
+  if (time_fd != NULL) {
+    lua_getglobal(lstate, "require");
+    // Must do this after nlua_common_vim_init where nlua_global_refs is initialized.
+    require_ref = nlua_ref_global(lstate, -1);
+    lua_pop(lstate, 1);
+    lua_pushcfunction(lstate, &nlua_require);
+    lua_setglobal(lstate, "require");
+  }
 
   // internal vim._treesitter... API
   nlua_add_treesitter(lstate);
 
-  // vim.loop
-  luv_set_loop(lstate, &main_loop.uv);
-  luv_set_callback(lstate, nlua_luv_cfpcall);
-  luaopen_luv(lstate);
-  lua_pushvalue(lstate, -1);
-  lua_setfield(lstate, -3, "loop");
-
-  // package.loaded.luv = vim.loop
-  // otherwise luv will be reinitialized when require'luv'
-  lua_getglobal(lstate, "package");
-  lua_getfield(lstate, -1, "loaded");
-  lua_pushvalue(lstate, -3);
-  lua_setfield(lstate, -2, "luv");
-  lua_pop(lstate, 3);
-
-  nlua_state_add_stdlib(lstate);
+  nlua_state_add_stdlib(lstate, false);
 
   lua_setglobal(lstate, "vim");
 
-  {
-    const char *code = (char *)&shared_module[0];
-    if (luaL_loadbuffer(lstate, code, sizeof(shared_module) - 1, "@vim/shared.lua")
-        || nlua_pcall(lstate, 0, 0)) {
-      nlua_error(lstate, _("E5106: Error while creating shared module: %.*s\n"));
-      return 1;
-    }
-  }
-
-  {
-    lua_getglobal(lstate, "package");  // [package]
-    lua_getfield(lstate, -1, "loaded");  // [package, loaded]
-
-    const char *code = (char *)&inspect_module[0];
-    if (luaL_loadbuffer(lstate, code, sizeof(inspect_module) - 1, "@vim/inspect.lua")
-        || nlua_pcall(lstate, 0, 1)) {
-      nlua_error(lstate, _("E5106: Error while creating inspect module: %.*s\n"));
-      return 1;
-    }
-    // [package, loaded, inspect]
-    lua_setfield(lstate, -2, "vim.inspect");  // [package, loaded]
-
-    code = (char *)&lua_F_module[0];
-    if (luaL_loadbuffer(lstate, code, sizeof(lua_F_module) - 1, "@vim/F.lua")
-        || nlua_pcall(lstate, 0, 1)) {
-      nlua_error(lstate, _("E5106: Error while creating vim.F module: %.*s\n"));
-      return 1;
-    }
-    // [package, loaded, module]
-    lua_setfield(lstate, -2, "vim.F");  // [package, loaded]
-
-    code = (char *)&lua_filetype_module[0];
-    if (luaL_loadbuffer(lstate, code, sizeof(lua_filetype_module) - 1, "@vim/filetype.lua")
-        || nlua_pcall(lstate, 0, 1)) {
-      nlua_error(lstate, _("E5106: Error while creating vim.filetype module: %.*s"));
-      return 1;
-    }
-    // [package, loaded, module]
-    lua_setfield(lstate, -2, "vim.filetype");  // [package, loaded]
-
-    lua_pop(lstate, 2);  // []
-  }
-
-  {
-    const char *code = (char *)&vim_module[0];
-    if (luaL_loadbuffer(lstate, code, sizeof(vim_module) - 1, "@vim.lua")
-        || nlua_pcall(lstate, 0, 0)) {
-      nlua_error(lstate, _("E5106: Error while creating vim module: %.*s\n"));
-      return 1;
-    }
-  }
-
-  {
-    lua_getglobal(lstate, "package");  // [package]
-    lua_getfield(lstate, -1, "loaded");  // [package, loaded]
-
-    const char *code = (char *)&lua_meta_module[0];
-    if (luaL_loadbuffer(lstate, code, sizeof(lua_meta_module) - 1, "@vim/_meta.lua")
-        || nlua_pcall(lstate, 0, 1)) {
-      nlua_error(lstate, _("E5106: Error while creating vim._meta module: %.*s\n"));
-      return 1;
-    }
-    // [package, loaded, module]
-    lua_setfield(lstate, -2, "vim._meta");  // [package, loaded]
-
-    lua_pop(lstate, 2);  // []
+  if (!nlua_init_packages(lstate)) {
+    return false;
   }
 
-  return 0;
+  return true;
 }
 
 /// Initialize global lua interpreter
@@ -488,15 +686,66 @@ void nlua_init(void)
 
   lua_State *lstate = luaL_newstate();
   if (lstate == NULL) {
-    emsg(_("E970: Failed to initialize lua interpreter"));
-    preserve_exit();
+    mch_errmsg(_("E970: Failed to initialize lua interpreter\n"));
+    os_exit(1);
   }
   luaL_openlibs(lstate);
-  nlua_state_init(lstate);
+  if (!nlua_state_init(lstate)) {
+    mch_errmsg(_("E970: Failed to initialize builtin lua modules\n"));
+    os_exit(1);
+  }
+
+  luv_set_thread_cb(nlua_thread_acquire_vm, nlua_common_free_all_mem);
 
   global_lstate = lstate;
+
+  main_thread = uv_thread_self();
 }
 
+static lua_State *nlua_thread_acquire_vm(void)
+{
+  // If it is called from the main thread, it will attempt to rebuild the cache.
+  const uv_thread_t self = uv_thread_self();
+  if (uv_thread_equal(&main_thread, &self)) {
+    runtime_search_path_validate();
+  }
+
+  lua_State *lstate = luaL_newstate();
+
+  // Add in the lua standard libraries
+  luaL_openlibs(lstate);
+
+  // print
+  lua_pushcfunction(lstate, &nlua_print);
+  lua_setglobal(lstate, "print");
+
+  lua_pushinteger(lstate, 0);
+  lua_setfield(lstate, LUA_REGISTRYINDEX, "nlua.refcount");
+
+  // vim
+  lua_newtable(lstate);
+
+  nlua_common_vim_init(lstate, true);
+
+  nlua_state_add_stdlib(lstate, true);
+
+  lua_createtable(lstate, 0, 0);
+  lua_pushcfunction(lstate, nlua_thr_api_nvim__get_runtime);
+  lua_setfield(lstate, -2, "nvim__get_runtime");
+  lua_setfield(lstate, -2, "api");
+
+  lua_setglobal(lstate, "vim");
+
+  nlua_init_packages(lstate);
+
+  lua_getglobal(lstate, "package");
+  lua_getfield(lstate, -1, "loaded");
+  lua_getglobal(lstate, "vim");
+  lua_setfield(lstate, -2, "vim");
+  lua_pop(lstate, 2);
+
+  return lstate;
+}
 
 void nlua_free_all_mem(void)
 {
@@ -504,30 +753,35 @@ void nlua_free_all_mem(void)
     return;
   }
   lua_State *lstate = global_lstate;
+  nlua_unref_global(lstate, require_ref);
+  nlua_common_free_all_mem(lstate);
+}
 
-  nlua_unref(lstate, nlua_nil_ref);
-  nlua_unref(lstate, nlua_empty_dict_ref);
+static void nlua_common_free_all_mem(lua_State *lstate)
+  FUNC_ATTR_NONNULL_ALL
+{
+  nlua_ref_state_t *ref_state = nlua_get_ref_state(lstate);
+  nlua_unref(lstate, ref_state, ref_state->nil_ref);
+  nlua_unref(lstate, ref_state, ref_state->empty_dict_ref);
 
 #ifdef NLUA_TRACK_REFS
-  if (nlua_refcount) {
-    fprintf(stderr, "%d lua references were leaked!", nlua_refcount);
+  if (ref_state->ref_count) {
+    fprintf(stderr, "%d lua references were leaked!", ref_state->ref_count);
   }
 
   if (nlua_track_refs) {
     // in case there are leaked luarefs, leak the associated memory
     // to get LeakSanitizer stacktraces on exit
-    pmap_destroy(handle_T)(&nlua_ref_markers);
+    pmap_destroy(handle_T)(&ref_state->ref_markers);
   }
 #endif
 
-  nlua_refcount = 0;
   lua_close(lstate);
 }
-
 static void nlua_print_event(void **argv)
 {
   char *str = argv[0];
-  const size_t len = (size_t)(intptr_t)argv[1]-1;  // exclude final NUL
+  const size_t len = (size_t)(intptr_t)argv[1] - 1;  // exclude final NUL
 
   for (size_t i = 0; i < len;) {
     if (got_int) {
@@ -601,9 +855,18 @@ static int nlua_print(lua_State *const lstate)
 #undef PRINT_ERROR
   ga_append(&msg_ga, NUL);
 
-  if (in_fast_callback) {
+  lua_getfield(lstate, LUA_REGISTRYINDEX, "nvim.thread");
+  bool is_thread = lua_toboolean(lstate, -1);
+  lua_pop(lstate, 1);
+
+  if (is_thread) {
+    loop_schedule_deferred(&main_loop,
+                           event_create(nlua_print_event, 2,
+                                        msg_ga.ga_data,
+                                        (intptr_t)msg_ga.ga_len));
+  } else if (in_fast_callback) {
     multiqueue_put(main_loop.events, nlua_print_event,
-                   2, msg_ga.ga_data, msg_ga.ga_len);
+                   2, msg_ga.ga_data, (intptr_t)msg_ga.ga_len);
   } else {
     nlua_print_event((void *[]){ msg_ga.ga_data,
                                  (void *)(intptr_t)msg_ga.ga_len });
@@ -612,13 +875,71 @@ static int nlua_print(lua_State *const lstate)
 
 nlua_print_error:
   ga_clear(&msg_ga);
+  char *buff = xmalloc(IOSIZE);
   const char *fmt = _("E5114: Error while converting print argument #%i: %.*s");
-  size_t len = (size_t)vim_snprintf((char *)IObuff, IOSIZE, fmt, curargidx,
+  size_t len = (size_t)vim_snprintf(buff, IOSIZE, fmt, curargidx,
                                     (int)errmsg_len, errmsg);
-  lua_pushlstring(lstate, (char *)IObuff, len);
+  lua_pushlstring(lstate, buff, len);
+  xfree(buff);
   return lua_error(lstate);
 }
 
+/// require() for --startuptime
+///
+/// @param  lstate  Lua interpreter state.
+static int nlua_require(lua_State *const lstate)
+  FUNC_ATTR_NONNULL_ALL
+{
+  const char *name = luaL_checkstring(lstate, 1);
+  lua_settop(lstate, 1);
+  // [ name ]
+
+  // try cached module from package.loaded first
+  lua_getfield(lstate, LUA_REGISTRYINDEX, "_LOADED");
+  lua_getfield(lstate, 2, name);
+  // [ name package.loaded module ]
+  if (lua_toboolean(lstate, -1)) {
+    return 1;
+  }
+  lua_pop(lstate, 2);
+  // [ name ]
+
+  // push original require below the module name
+  nlua_pushref(lstate, require_ref);
+  lua_insert(lstate, 1);
+  // [ require name ]
+
+  if (time_fd == NULL) {
+    // after log file was closed, try to restore
+    // global require to the original function...
+    lua_getglobal(lstate, "require");
+    // ...only if it's still referencing this wrapper,
+    // to not overwrite it in case someone happened to
+    // patch it in the meantime...
+    if (lua_iscfunction(lstate, -1) && lua_tocfunction(lstate, -1) == nlua_require) {
+      lua_pushvalue(lstate, 1);
+      lua_setglobal(lstate, "require");
+    }
+    lua_pop(lstate, 1);
+
+    // ...and then call require directly.
+    lua_call(lstate, 1, 1);
+    return 1;
+  }
+
+  proftime_T rel_time;
+  proftime_T start_time;
+  time_push(&rel_time, &start_time);
+  int status = lua_pcall(lstate, 1, 1, 0);
+  if (status == 0) {
+    vim_snprintf((char *)IObuff, IOSIZE, "require('%s')", name);
+    time_msg((char *)IObuff, &start_time);
+  }
+  time_pop(rel_time);
+
+  return status == 0 ? 1 : lua_error(lstate);
+}
+
 /// debug.debug: interaction with user while debugging.
 ///
 /// @param  lstate  Lua interpreter state.
@@ -629,7 +950,7 @@ static int nlua_debug(lua_State *lstate)
     {
       .v_lock = VAR_FIXED,
       .v_type = VAR_STRING,
-      .vval.v_string = (char_u *)"lua_debug> ",
+      .vval.v_string = "lua_debug> ",
     },
     {
       .v_type = VAR_UNKNOWN,
@@ -664,16 +985,26 @@ int nlua_in_fast_event(lua_State *lstate)
   return 1;
 }
 
+static bool viml_func_is_fast(const char *name)
+{
+  const EvalFuncDef *const fdef = find_internal_func((const char *)name);
+  if (fdef) {
+    return fdef->fast;
+  }
+  // Not a vimL function
+  return false;
+}
+
 int nlua_call(lua_State *lstate)
 {
   Error err = ERROR_INIT;
   size_t name_len;
-  const char_u *name = (const char_u *)luaL_checklstring(lstate, 1, &name_len);
-  if (!nlua_is_deferred_safe()) {
+  const char *name = luaL_checklstring(lstate, 1, &name_len);
+  if (!nlua_is_deferred_safe() && !viml_func_is_fast(name)) {
     return luaL_error(lstate, e_luv_api_disabled, "vimL function");
   }
 
-  int nargs = lua_gettop(lstate)-1;
+  int nargs = lua_gettop(lstate) - 1;
   if (nargs > MAX_FUNC_ARGS) {
     return luaL_error(lstate, "Function called with too many arguments");
   }
@@ -681,10 +1012,10 @@ int nlua_call(lua_State *lstate)
   typval_T vim_args[MAX_FUNC_ARGS + 1];
   int i = 0;  // also used for freeing the variables
   for (; i < nargs; i++) {
-    lua_pushvalue(lstate, (int)i+2);
+    lua_pushvalue(lstate, i + 2);
     if (!nlua_pop_typval(lstate, &vim_args[i])) {
       api_set_error(&err, kErrorTypeException,
-                    "error converting argument %d", i+1);
+                    "error converting argument %d", i + 1);
       goto free_vim_args;
     }
   }
@@ -704,7 +1035,7 @@ int nlua_call(lua_State *lstate)
     funcexe.evaluate = true;
     // call_func() retval is deceptive, ignore it.  Instead we set `msg_list`
     // (TRY_WRAP) to capture abort-causing non-exception errors.
-    (void)call_func(name, (int)name_len, &rettv, nargs, vim_args, &funcexe);
+    (void)call_func((char *)name, (int)name_len, &rettv, nargs, vim_args, &funcexe);
     if (!try_end(&err)) {
       nlua_push_typval(lstate, &rettv, false);
     }
@@ -741,12 +1072,12 @@ static int nlua_rpc(lua_State *lstate, bool request)
   size_t name_len;
   uint64_t chan_id = (uint64_t)luaL_checkinteger(lstate, 1);
   const char *name = luaL_checklstring(lstate, 2, &name_len);
-  int nargs = lua_gettop(lstate)-2;
+  int nargs = lua_gettop(lstate) - 2;
   Error err = ERROR_INIT;
   Array args = ARRAY_DICT_INIT;
 
   for (int i = 0; i < nargs; i++) {
-    lua_pushvalue(lstate, (int)i+3);
+    lua_pushvalue(lstate, i + 3);
     ADD(args, nlua_pop_Object(lstate, false, &err));
     if (ERROR_SET(&err)) {
       api_free_array(args);
@@ -755,10 +1086,11 @@ static int nlua_rpc(lua_State *lstate, bool request)
   }
 
   if (request) {
-    Object result = rpc_send_call(chan_id, name, args, &err);
+    ArenaMem res_mem = NULL;
+    Object result = rpc_send_call(chan_id, name, args, &res_mem, &err);
     if (!ERROR_SET(&err)) {
       nlua_push_Object(lstate, result, false);
-      api_free_object(result);
+      arena_mem_free(res_mem, NULL);
     }
   } else {
     if (!rpc_send_event(chan_id, name, args)) {
@@ -789,7 +1121,6 @@ static int nlua_empty_dict_tostring(lua_State *lstate)
   return 1;
 }
 
-
 #ifdef WIN32
 /// os.getenv: override os.getenv to maintain coherency. #9681
 ///
@@ -803,42 +1134,52 @@ static int nlua_getenv(lua_State *lstate)
 }
 #endif
 
-
 /// add the value to the registry
-LuaRef nlua_ref(lua_State *lstate, int index)
+/// The current implementation does not support calls from threads.
+LuaRef nlua_ref(lua_State *lstate, nlua_ref_state_t *ref_state, int index)
 {
   lua_pushvalue(lstate, index);
   LuaRef ref = luaL_ref(lstate, LUA_REGISTRYINDEX);
   if (ref > 0) {
-    nlua_refcount++;
+    ref_state->ref_count++;
 #ifdef NLUA_TRACK_REFS
     if (nlua_track_refs) {
       // dummy allocation to make LeakSanitizer track our luarefs
-      pmap_put(handle_T)(&nlua_ref_markers, ref, xmalloc(3));
+      pmap_put(handle_T)(&ref_state->ref_markers, ref, xmalloc(3));
     }
 #endif
   }
   return ref;
 }
 
+LuaRef nlua_ref_global(lua_State *lstate, int index)
+{
+  return nlua_ref(lstate, nlua_global_refs, index);
+}
+
 /// remove the value from the registry
-void nlua_unref(lua_State *lstate, LuaRef ref)
+void nlua_unref(lua_State *lstate, nlua_ref_state_t *ref_state, LuaRef ref)
 {
   if (ref > 0) {
-    nlua_refcount--;
+    ref_state->ref_count--;
 #ifdef NLUA_TRACK_REFS
     // NB: don't remove entry from map to track double-unref
     if (nlua_track_refs) {
-      xfree(pmap_get(handle_T)(&nlua_ref_markers, ref));
+      xfree(pmap_get(handle_T)(&ref_state->ref_markers, ref));
     }
 #endif
     luaL_unref(lstate, LUA_REGISTRYINDEX, ref);
   }
 }
 
+void nlua_unref_global(lua_State *lstate, LuaRef ref)
+{
+  nlua_unref(lstate, nlua_global_refs, ref);
+}
+
 void api_free_luaref(LuaRef ref)
 {
-  nlua_unref(global_lstate, ref);
+  nlua_unref_global(global_lstate, ref);
 }
 
 /// push a value referenced in the registry
@@ -847,7 +1188,6 @@ void nlua_pushref(lua_State *lstate, LuaRef ref)
   lua_rawgeti(lstate, LUA_REGISTRYINDEX, ref);
 }
 
-
 /// Gets a new reference to an object stored at original_ref
 ///
 /// NOTE: It does not copy the value, it creates a new ref to the lua object.
@@ -860,12 +1200,11 @@ LuaRef api_new_luaref(LuaRef original_ref)
 
   lua_State *const lstate = global_lstate;
   nlua_pushref(lstate, original_ref);
-  LuaRef new_ref = nlua_ref(lstate, -1);
+  LuaRef new_ref = nlua_ref_global(lstate,  -1);
   lua_pop(lstate, 1);
   return new_ref;
 }
 
-
 /// Evaluate lua string
 ///
 /// Used for luaeval().
@@ -930,8 +1269,8 @@ void nlua_call_user_expand_func(expand_T *xp, typval_T *ret_tv)
   lua_State *const lstate = global_lstate;
 
   nlua_pushref(lstate, xp->xp_luaref);
-  lua_pushstring(lstate, (char *)xp->xp_pattern);
-  lua_pushstring(lstate, (char *)xp->xp_line);
+  lua_pushstring(lstate, xp->xp_pattern);
+  lua_pushstring(lstate, xp->xp_line);
   lua_pushinteger(lstate, xp->xp_col);
 
   if (nlua_pcall(lstate, 3, 1)) {
@@ -984,7 +1323,7 @@ int nlua_source_using_linegetter(LineGetter fgetline, void *cookie, char *name)
   char_u *line = NULL;
 
   ga_init(&ga, (int)sizeof(char_u *), 10);
-  while ((line = fgetline(0, cookie, 0, false)) != NULL) {
+  while ((line = (char_u *)fgetline(0, cookie, 0, false)) != NULL) {
     GA_APPEND(char_u *, &ga, line);
   }
   char *code = ga_concat_strings_sep(&ga, "\n");
@@ -1062,6 +1401,19 @@ Object nlua_exec(const String str, const Array args, Error *err)
   return nlua_pop_Object(lstate, false, err);
 }
 
+bool nlua_ref_is_function(LuaRef ref)
+{
+  lua_State *const lstate = global_lstate;
+  nlua_pushref(lstate, ref);
+
+  // TODO(tjdevries): This should probably check for callable tables as well.
+  //                    We should put some work maybe into simplifying how all of that works
+  bool is_function = (lua_type(lstate, -1) == LUA_TFUNCTION);
+  lua_pop(lstate, 1);
+
+  return is_function;
+}
+
 /// call a LuaRef as a function (or table with __call metamethod)
 ///
 /// @param ref     the reference to call (not consumed)
@@ -1136,7 +1488,7 @@ void ex_lua(exarg_T *const eap)
     // lua nlua_typval_exec doesn't expect null terminated string so len
     // needs to end before null byte.
     char *code_buf = xmallocz(len);
-    vim_snprintf(code_buf, len+1, "vim.pretty_print(%s)", code+1);
+    vim_snprintf(code_buf, len + 1, "vim.pretty_print(%s)", code + 1);
     xfree(code);
     code = code_buf;
   }
@@ -1217,7 +1569,7 @@ void ex_luado(exarg_T *const eap)
           new_line_transformed[i] = '\n';
         }
       }
-      ml_replace(l, (char_u *)new_line_transformed, false);
+      ml_replace(l, new_line_transformed, false);
       inserted_bytes(l, 0, (int)old_line_len, (int)new_line_len);
     }
     lua_pop(lstate, 1);
@@ -1240,6 +1592,9 @@ void ex_luafile(exarg_T *const eap)
 
 /// execute lua code from a file.
 ///
+/// Note: we call the lua global loadfile as opposed to calling luaL_loadfile
+/// in case loadfile has been overridden in the users environment.
+///
 /// @param  path  path of the file
 ///
 /// @return  true if everything ok, false if there was an error (echoed)
@@ -1248,11 +1603,30 @@ bool nlua_exec_file(const char *path)
 {
   lua_State *const lstate = global_lstate;
 
-  if (luaL_loadfile(lstate, path)) {
+  lua_getglobal(lstate, "loadfile");
+  lua_pushstring(lstate, path);
+
+  if (nlua_pcall(lstate, 1, 2)) {
+    nlua_error(lstate, _("E5111: Error calling lua: %.*s"));
+    return false;
+  }
+
+  // loadstring() returns either:
+  //  1. nil, error
+  //  2. chunk, nil
+
+  if (lua_isnil(lstate, -2)) {
+    // 1
     nlua_error(lstate, _("E5112: Error while creating lua chunk: %.*s"));
+    assert(lua_isnil(lstate, -1));
+    lua_pop(lstate, 1);
     return false;
   }
 
+  // 2
+  assert(lua_isnil(lstate, -1));
+  lua_pop(lstate, 1);
+
   if (nlua_pcall(lstate, 0, 0)) {
     nlua_error(lstate, _("E5113: Error while calling lua chunk: %.*s"));
     return false;
@@ -1267,6 +1641,12 @@ int tslua_get_language_version(lua_State *L)
   return 1;
 }
 
+int tslua_get_minimum_language_version(lua_State *L)
+{
+  lua_pushnumber(L, TREE_SITTER_MIN_COMPATIBLE_LANGUAGE_VERSION);
+  return 1;
+}
+
 static void nlua_add_treesitter(lua_State *const lstate) FUNC_ATTR_NONNULL_ALL
 {
   tslua_init(lstate);
@@ -1288,6 +1668,9 @@ static void nlua_add_treesitter(lua_State *const lstate) FUNC_ATTR_NONNULL_ALL
 
   lua_pushcfunction(lstate, tslua_get_language_version);
   lua_setfield(lstate, -2, "_ts_get_language_version");
+
+  lua_pushcfunction(lstate, tslua_get_minimum_language_version);
+  lua_setfield(lstate, -2, "_ts_get_minimum_language_version");
 }
 
 int nlua_expand_pat(expand_T *xp, char_u *pat, int *num_results, char_u ***results)
@@ -1338,9 +1721,7 @@ int nlua_expand_pat(expand_T *xp, char_u *pat, int *num_results, char_u ***resul
       goto cleanup_array;
     }
 
-    GA_APPEND(char_u *,
-              &result_array,
-              vim_strsave((char_u *)v.data.string.data));
+    GA_APPEND(char_u *, &result_array, (char_u *)string_to_cstr(v.data.string));
   }
 
   xp->xp_pattern += prefix_len;
@@ -1359,6 +1740,13 @@ cleanup:
   return ret;
 }
 
+static int nlua_is_thread(lua_State *lstate)
+{
+  lua_getfield(lstate, LUA_REGISTRYINDEX, "nvim.thread");
+
+  return 1;
+}
+
 // Required functions for lua c functions as VimL callbacks
 
 int nlua_CFunction_func_call(int argcount, typval_T *argvars, typval_T *rettv, void *state)
@@ -1375,7 +1763,7 @@ void nlua_CFunction_func_free(void *state)
   lua_State *const lstate = global_lstate;
   LuaCFunctionState *funcstate = (LuaCFunctionState *)state;
 
-  nlua_unref(lstate, funcstate->lua_callable.func_ref);
+  nlua_unref_global(lstate, funcstate->lua_callable.func_ref);
   xfree(funcstate);
 }
 
@@ -1425,12 +1813,11 @@ char_u *nlua_register_table_as_callable(typval_T *const arg)
   lua_pop(lstate, 2);  // [table]
 
   LuaCFunctionState *state = xmalloc(sizeof(LuaCFunctionState));
-  state->lua_callable.func_ref = nlua_ref(lstate, -1);
+  state->lua_callable.func_ref = nlua_ref_global(lstate, -1);
 
   char_u *name = register_cfunc(&nlua_CFunction_func_call,
                                 &nlua_CFunction_func_free, state);
 
-
   lua_pop(lstate, 1);  // []
   assert(top == lua_gettop(lstate));
 
@@ -1458,10 +1845,13 @@ void nlua_execute_on_key(int c)
   // [ vim, vim._on_key, buf ]
   lua_pushlstring(lstate, (const char *)buf, buf_len);
 
+  int save_got_int = got_int;
+  got_int = false;  // avoid interrupts when the key typed is Ctrl-C
   if (nlua_pcall(lstate, 1, 0)) {
     nlua_error(lstate,
                _("Error executing  vim.on_key Lua callback: %.*s"));
   }
+  got_int |= save_got_int;
 
   // [ vim ]
   lua_pop(lstate, 1);
@@ -1472,11 +1862,64 @@ void nlua_execute_on_key(int c)
 #endif
 }
 
-void nlua_do_ucmd(ucmd_T *cmd, exarg_T *eap)
+// Sets the editor "script context" during Lua execution. Used by :verbose.
+// @param[out] current
+void nlua_set_sctx(sctx_T *current)
 {
+  if (p_verbose <= 0 || current->sc_sid != SID_LUA) {
+    return;
+  }
   lua_State *const lstate = global_lstate;
+  lua_Debug *info = (lua_Debug *)xmalloc(sizeof(lua_Debug));
+
+  // Files where internal wrappers are defined so we can ignore them
+  // like vim.o/opt etc are defined in _meta.lua
+  char *ignorelist[] = {
+    "vim/_meta.lua",
+    "vim/keymap.lua",
+  };
+  int ignorelist_size = sizeof(ignorelist) / sizeof(ignorelist[0]);
 
-  nlua_pushref(lstate, cmd->uc_luaref);
+  for (int level = 1; true; level++) {
+    if (lua_getstack(lstate, level, info) != 1) {
+      goto cleanup;
+    }
+    if (lua_getinfo(lstate, "nSl", info) == 0) {
+      goto cleanup;
+    }
+
+    bool is_ignored = false;
+    if (info->what[0] == 'C' || info->source[0] != '@') {
+      is_ignored = true;
+    } else {
+      for (int i = 0; i < ignorelist_size; i++) {
+        if (strncmp(ignorelist[i], info->source + 1, strlen(ignorelist[i])) == 0) {
+          is_ignored = true;
+          break;
+        }
+      }
+    }
+    if (is_ignored) {
+      continue;
+    }
+    break;
+  }
+  char *source_path = fix_fname(info->source + 1);
+  get_current_script_id((char_u *)source_path, current);
+  xfree(source_path);
+  current->sc_lnum = info->currentline;
+  current->sc_seq = -1;
+
+cleanup:
+  xfree(info);
+}
+
+/// @param preview Invoke the callback as a |:command-preview| handler.
+int nlua_do_ucmd(ucmd_T *cmd, exarg_T *eap, bool preview)
+{
+  lua_State *const lstate = global_lstate;
+
+  nlua_pushref(lstate, preview ? cmd->uc_preview_luaref : cmd->uc_luaref);
 
   lua_newtable(lstate);
   lua_pushboolean(lstate, eap->forceit == 1);
@@ -1488,8 +1931,42 @@ void nlua_do_ucmd(ucmd_T *cmd, exarg_T *eap)
   lua_pushinteger(lstate, eap->line2);
   lua_setfield(lstate, -2, "line2");
 
+  lua_newtable(lstate);  // f-args table
   lua_pushstring(lstate, (const char *)eap->arg);
-  lua_setfield(lstate, -2, "args");
+  lua_pushvalue(lstate, -1);  // Reference for potential use on f-args
+  lua_setfield(lstate, -4, "args");
+
+  // Split args by unescaped whitespace |<f-args>| (nargs dependent)
+  if (cmd->uc_argt & EX_NOSPC) {
+    // Commands where nargs = 1 or "?" fargs is the same as args
+    lua_rawseti(lstate, -2, 1);
+  } else if (eap->args == NULL) {
+    // For commands with more than one possible argument, split if argument list isn't available.
+    lua_pop(lstate, 1);  // Pop the reference of opts.args
+    size_t length = STRLEN(eap->arg);
+    size_t end = 0;
+    size_t len = 0;
+    int i = 1;
+    char *buf = xcalloc(length, sizeof(char));
+    bool done = false;
+    while (!done) {
+      done = uc_split_args_iter(eap->arg, length, &end, buf, &len);
+      if (len > 0) {
+        lua_pushlstring(lstate, buf, len);
+        lua_rawseti(lstate, -2, i);
+        i++;
+      }
+    }
+    xfree(buf);
+  } else {
+    // If argument list is available, just use it.
+    lua_pop(lstate, 1);
+    for (size_t i = 0; i < eap->argc; i++) {
+      lua_pushlstring(lstate, eap->args[i], eap->arglens[i]);
+      lua_rawseti(lstate, -2, (int)i + 1);
+    }
+  }
+  lua_setfield(lstate, -2, "fargs");
 
   lua_pushstring(lstate, (const char *)&eap->regname);
   lua_setfield(lstate, -2, "reg");
@@ -1508,12 +1985,93 @@ void nlua_do_ucmd(ucmd_T *cmd, exarg_T *eap)
   // every possible modifier (with room to spare). If the list of possible
   // modifiers grows this may need to be updated.
   char buf[200] = { 0 };
-  (void)uc_mods(buf);
+  (void)uc_mods(buf, &cmdmod, false);
   lua_pushstring(lstate, buf);
   lua_setfield(lstate, -2, "mods");
 
-  if (nlua_pcall(lstate, 1, 0)) {
+  lua_newtable(lstate);  // smods table
+
+  lua_pushinteger(lstate, cmdmod.cmod_tab);
+  lua_setfield(lstate, -2, "tab");
+
+  lua_pushinteger(lstate, cmdmod.cmod_verbose - 1);
+  lua_setfield(lstate, -2, "verbose");
+
+  if (cmdmod.cmod_split & WSP_ABOVE) {
+    lua_pushstring(lstate, "aboveleft");
+  } else if (cmdmod.cmod_split & WSP_BELOW) {
+    lua_pushstring(lstate, "belowright");
+  } else if (cmdmod.cmod_split & WSP_TOP) {
+    lua_pushstring(lstate, "topleft");
+  } else if (cmdmod.cmod_split & WSP_BOT) {
+    lua_pushstring(lstate, "botright");
+  } else {
+    lua_pushstring(lstate, "");
+  }
+  lua_setfield(lstate, -2, "split");
+
+  lua_pushboolean(lstate, cmdmod.cmod_split & WSP_VERT);
+  lua_setfield(lstate, -2, "vertical");
+  lua_pushboolean(lstate, cmdmod.cmod_flags & CMOD_SILENT);
+  lua_setfield(lstate, -2, "silent");
+  lua_pushboolean(lstate, cmdmod.cmod_flags & CMOD_ERRSILENT);
+  lua_setfield(lstate, -2, "emsg_silent");
+  lua_pushboolean(lstate, cmdmod.cmod_flags & CMOD_UNSILENT);
+  lua_setfield(lstate, -2, "unsilent");
+  lua_pushboolean(lstate, cmdmod.cmod_flags & CMOD_SANDBOX);
+  lua_setfield(lstate, -2, "sandbox");
+  lua_pushboolean(lstate, cmdmod.cmod_flags & CMOD_NOAUTOCMD);
+  lua_setfield(lstate, -2, "noautocmd");
+
+  typedef struct {
+    int flag;
+    char *name;
+  } mod_entry_T;
+  static mod_entry_T mod_entries[] = {
+    { CMOD_BROWSE, "browse" },
+    { CMOD_CONFIRM, "confirm" },
+    { CMOD_HIDE, "hide" },
+    { CMOD_KEEPALT, "keepalt" },
+    { CMOD_KEEPJUMPS, "keepjumps" },
+    { CMOD_KEEPMARKS, "keepmarks" },
+    { CMOD_KEEPPATTERNS, "keeppatterns" },
+    { CMOD_LOCKMARKS, "lockmarks" },
+    { CMOD_NOSWAPFILE, "noswapfile" }
+  };
+
+  // The modifiers that are simple flags
+  for (size_t i = 0; i < ARRAY_SIZE(mod_entries); i++) {
+    lua_pushboolean(lstate, cmdmod.cmod_flags & mod_entries[i].flag);
+    lua_setfield(lstate, -2, mod_entries[i].name);
+  }
+
+  lua_setfield(lstate, -2, "smods");
+
+  if (preview) {
+    lua_pushinteger(lstate, cmdpreview_get_ns());
+
+    handle_T cmdpreview_bufnr = cmdpreview_get_bufnr();
+    if (cmdpreview_bufnr != 0) {
+      lua_pushinteger(lstate, cmdpreview_bufnr);
+    } else {
+      lua_pushnil(lstate);
+    }
+  }
+
+  if (nlua_pcall(lstate, preview ? 3 : 1, preview ? 1 : 0)) {
     nlua_error(lstate, _("Error executing Lua callback: %.*s"));
+    return 0;
+  }
+
+  int retv = 0;
+
+  if (preview) {
+    if (lua_isnumber(lstate, -1) && (retv = (int)lua_tointeger(lstate, -1)) >= 0 && retv <= 2) {
+      lua_pop(lstate, 1);
+    } else {
+      retv = 0;
+    }
   }
-}
 
+  return retv;
+}