From 04cdea5f4ac49fa62cc4091a5c26791b80b4cc4c Mon Sep 17 00:00:00 2001
From: Dundar Göc <gocdundar@gmail.com>
Date: Fri, 26 Aug 2022 23:11:25 +0200
Subject: refactor: replace char_u with char

Work on https://github.com/neovim/neovim/issues/459
---
 src/nvim/lua/executor.c   | 4 ++--
 src/nvim/lua/stdlib.c     | 8 ++++----
 src/nvim/lua/treesitter.c | 2 +-
 3 files changed, 7 insertions(+), 7 deletions(-)

(limited to 'src/nvim/lua')

diff --git a/src/nvim/lua/executor.c b/src/nvim/lua/executor.c
index f3821f149a..fca07ee146 100644
--- a/src/nvim/lua/executor.c
+++ b/src/nvim/lua/executor.c
@@ -1758,7 +1758,7 @@ static void nlua_add_treesitter(lua_State *const lstate) FUNC_ATTR_NONNULL_ALL
   lua_setfield(lstate, -2, "_ts_get_minimum_language_version");
 }
 
-int nlua_expand_pat(expand_T *xp, char_u *pat, int *num_results, char ***results)
+int nlua_expand_pat(expand_T *xp, char *pat, int *num_results, char ***results)
 {
   lua_State *const lstate = global_lstate;
   int ret = OK;
@@ -1771,7 +1771,7 @@ int nlua_expand_pat(expand_T *xp, char_u *pat, int *num_results, char ***results
   luaL_checktype(lstate, -1, LUA_TFUNCTION);
 
   // [ vim, vim._expand_pat, buf ]
-  lua_pushlstring(lstate, (const char *)pat, STRLEN(pat));
+  lua_pushlstring(lstate, (const char *)pat, strlen(pat));
 
   if (nlua_pcall(lstate, 1, 2) != 0) {
     nlua_error(lstate,
diff --git a/src/nvim/lua/stdlib.c b/src/nvim/lua/stdlib.c
index 2f46f6ff65..6974c6181c 100644
--- a/src/nvim/lua/stdlib.c
+++ b/src/nvim/lua/stdlib.c
@@ -111,14 +111,14 @@ static int regex_match_line(lua_State *lstate)
     return luaL_error(lstate, "invalid row");
   }
 
-  char_u *line = (char_u *)ml_get_buf(buf, rownr + 1, false);
-  size_t len = STRLEN(line);
+  char *line = ml_get_buf(buf, rownr + 1, false);
+  size_t len = strlen(line);
 
   if (start < 0 || (size_t)start > len) {
     return luaL_error(lstate, "invalid start");
   }
 
-  char_u save = NUL;
+  char save = NUL;
   if (end >= 0) {
     if ((size_t)end > len || end < start) {
       return luaL_error(lstate, "invalid end");
@@ -127,7 +127,7 @@ static int regex_match_line(lua_State *lstate)
     line[end] = NUL;
   }
 
-  int nret = regex_match(lstate, prog, line + start);
+  int nret = regex_match(lstate, prog, (char_u *)line + start);
 
   if (end >= 0) {
     line[end] = save;
diff --git a/src/nvim/lua/treesitter.c b/src/nvim/lua/treesitter.c
index 79b11eca4a..9d871939f8 100644
--- a/src/nvim/lua/treesitter.c
+++ b/src/nvim/lua/treesitter.c
@@ -333,7 +333,7 @@ static const char *input_cb(void *payload, uint32_t byte_index, TSPoint position
     return "";
   }
   char *line = ml_get_buf(bp, (linenr_T)position.row + 1, false);
-  size_t len = STRLEN(line);
+  size_t len = strlen(line);
   if (position.column > len) {
     *bytes_read = 0;
     return "";
-- 
cgit 


From b05d1943f063c382ea96b76d250877bc58297314 Mon Sep 17 00:00:00 2001
From: dundargoc <33953936+dundargoc@users.noreply.github.com>
Date: Tue, 1 Nov 2022 15:39:49 +0100
Subject: build(lint): remove clint.py rules for braces #20880

Uncrustify is the source of truth where possible.
Remove any redundant checks from clint.py.
See also https://github.com/neovim/neovim/pull/18563
---
 src/nvim/lua/executor.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/nvim/lua')

diff --git a/src/nvim/lua/executor.c b/src/nvim/lua/executor.c
index fca07ee146..9d63fe55f9 100644
--- a/src/nvim/lua/executor.c
+++ b/src/nvim/lua/executor.c
@@ -400,7 +400,7 @@ static int nlua_wait(lua_State *lstate)
 
   bool fast_only = false;
   if (lua_top >= 4) {
-    fast_only =  lua_toboolean(lstate, 4);
+    fast_only = lua_toboolean(lstate, 4);
   }
 
   MultiQueue *loop_events = fast_only || in_fast_callback > 0
-- 
cgit 


From 04fbb1de4488852c3ba332898b17180500f8984e Mon Sep 17 00:00:00 2001
From: Jonathon <32371757+jwhite510@users.noreply.github.com>
Date: Fri, 4 Nov 2022 05:07:22 -0400
Subject: Enable new diff option linematch (#14537)

Co-authored-by: Lewis Russell <me@lewisr.dev>
---
 src/nvim/lua/xdiff.c | 122 ++++++++++++++++++++++++++++++++++++++++-----------
 1 file changed, 96 insertions(+), 26 deletions(-)

(limited to 'src/nvim/lua')

diff --git a/src/nvim/lua/xdiff.c b/src/nvim/lua/xdiff.c
index b2b5dfedee..428a33cdad 100644
--- a/src/nvim/lua/xdiff.c
+++ b/src/nvim/lua/xdiff.c
@@ -10,12 +10,16 @@
 #include <string.h>
 
 #include "nvim/api/private/helpers.h"
+#include "nvim/linematch.h"
 #include "nvim/lua/converter.h"
 #include "nvim/lua/executor.h"
 #include "nvim/lua/xdiff.h"
 #include "nvim/vim.h"
 #include "xdiff/xdiff.h"
 
+#define COMPARED_BUFFER0 (1 << 0)
+#define COMPARED_BUFFER1 (1 << 1)
+
 typedef enum {
   kNluaXdiffModeUnified = 0,
   kNluaXdiffModeOnHunkCB,
@@ -25,12 +29,72 @@ typedef enum {
 typedef struct {
   lua_State *lstate;
   Error *err;
+  mmfile_t *ma;
+  mmfile_t *mb;
+  bool linematch;
+  bool iwhite;
 } hunkpriv_t;
 
 #ifdef INCLUDE_GENERATED_DECLARATIONS
 # include "lua/xdiff.c.generated.h"
 #endif
 
+static void lua_pushhunk(lua_State *lstate, long start_a, long count_a, long start_b, long count_b)
+{
+  lua_createtable(lstate, 0, 0);
+  lua_pushinteger(lstate, start_a);
+  lua_rawseti(lstate, -2, 1);
+  lua_pushinteger(lstate, count_a);
+  lua_rawseti(lstate, -2, 2);
+  lua_pushinteger(lstate, start_b);
+  lua_rawseti(lstate, -2, 3);
+  lua_pushinteger(lstate, count_b);
+  lua_rawseti(lstate, -2, 4);
+  lua_rawseti(lstate, -2, (signed)lua_objlen(lstate, -2) + 1);
+}
+
+static void get_linematch_results(lua_State *lstate, mmfile_t *ma, mmfile_t *mb, long start_a,
+                                  long count_a, long start_b, long count_b, bool iwhite)
+{
+  // get the pointer to char of the start of the diff to pass it to linematch algorithm
+  const char *diff_begin[2] = { ma->ptr, mb->ptr };
+  int diff_length[2] = { (int)count_a, (int)count_b };
+
+  fastforward_buf_to_lnum(&diff_begin[0], (size_t)start_a);
+  fastforward_buf_to_lnum(&diff_begin[1], (size_t)start_b);
+
+  int *decisions = NULL;
+  size_t decisions_length = linematch_nbuffers(diff_begin, diff_length, 2, &decisions, iwhite);
+
+  long lnuma = start_a, lnumb = start_b;
+
+  long hunkstarta = lnuma;
+  long hunkstartb = lnumb;
+  long hunkcounta = 0;
+  long hunkcountb = 0;
+  for (size_t i = 0; i < decisions_length; i++) {
+    if (i && (decisions[i - 1] != decisions[i])) {
+      lua_pushhunk(lstate, hunkstarta, hunkcounta, hunkstartb, hunkcountb);
+
+      hunkstarta = lnuma;
+      hunkstartb = lnumb;
+      hunkcounta = 0;
+      hunkcountb = 0;
+      // create a new hunk
+    }
+    if (decisions[i] & COMPARED_BUFFER0) {
+      lnuma++;
+      hunkcounta++;
+    }
+    if (decisions[i] & COMPARED_BUFFER1) {
+      lnumb++;
+      hunkcountb++;
+    }
+  }
+  lua_pushhunk(lstate, hunkstarta, hunkcounta, hunkstartb, hunkcountb);
+  xfree(decisions);
+}
+
 static int write_string(void *priv, mmbuffer_t *mb, int nbuf)
 {
   luaL_Buffer *buf = (luaL_Buffer *)priv;
@@ -61,20 +125,14 @@ static int hunk_locations_cb(long start_a, long count_a, long start_b, long coun
   if (count_b > 0) {
     start_b += 1;
   }
-
-  lua_State *lstate = (lua_State *)cb_data;
-  lua_createtable(lstate, 0, 0);
-
-  lua_pushinteger(lstate, start_a);
-  lua_rawseti(lstate, -2, 1);
-  lua_pushinteger(lstate, count_a);
-  lua_rawseti(lstate, -2, 2);
-  lua_pushinteger(lstate, start_b);
-  lua_rawseti(lstate, -2, 3);
-  lua_pushinteger(lstate, count_b);
-  lua_rawseti(lstate, -2, 4);
-
-  lua_rawseti(lstate, -2, (signed)lua_objlen(lstate, -2) + 1);
+  hunkpriv_t *priv = (hunkpriv_t *)cb_data;
+  lua_State *lstate = priv->lstate;
+  if (priv->linematch) {
+    get_linematch_results(lstate, priv->ma, priv->mb, start_a, count_a, start_b, count_b,
+                          priv->iwhite);
+  } else {
+    lua_pushhunk(lstate, start_a, count_a, start_b, count_b);
+  }
 
   return 0;
 }
@@ -149,7 +207,7 @@ static bool check_xdiff_opt(ObjectType actType, ObjectType expType, const char *
 }
 
 static NluaXdiffMode process_xdl_diff_opts(lua_State *lstate, xdemitconf_t *cfg, xpparam_t *params,
-                                           Error *err)
+                                           bool *linematch, Error *err)
 {
   const DictionaryOf(LuaRef) opts = nlua_pop_Dictionary(lstate, true, err);
 
@@ -205,6 +263,11 @@ static NluaXdiffMode process_xdl_diff_opts(lua_State *lstate, xdemitconf_t *cfg,
         goto exit_1;
       }
       cfg->interhunkctxlen = v->data.integer;
+    } else if (strequal("linematch", k.data)) {
+      *linematch = api_object_to_bool(*v, "linematch", false, err);
+      if (ERROR_SET(err)) {
+        goto exit_1;
+      }
     } else {
       struct {
         const char *name;
@@ -244,10 +307,8 @@ static NluaXdiffMode process_xdl_diff_opts(lua_State *lstate, xdemitconf_t *cfg,
 
   if (had_on_hunk) {
     mode = kNluaXdiffModeOnHunkCB;
-    cfg->hunk_func = call_on_hunk_cb;
   } else if (had_result_type_indices) {
     mode = kNluaXdiffModeLocations;
-    cfg->hunk_func = hunk_locations_cb;
   }
 
 exit_1:
@@ -268,6 +329,7 @@ int nlua_xdl_diff(lua_State *lstate)
   xdemitconf_t cfg;
   xpparam_t params;
   xdemitcb_t ecb;
+  bool linematch = false;
 
   CLEAR_FIELD(cfg);
   CLEAR_FIELD(params);
@@ -280,7 +342,7 @@ int nlua_xdl_diff(lua_State *lstate)
       return luaL_argerror(lstate, 3, "expected table");
     }
 
-    mode = process_xdl_diff_opts(lstate, &cfg, &params, &err);
+    mode = process_xdl_diff_opts(lstate, &cfg, &params, &linematch, &err);
 
     if (ERROR_SET(&err)) {
       goto exit_0;
@@ -288,7 +350,7 @@ int nlua_xdl_diff(lua_State *lstate)
   }
 
   luaL_Buffer buf;
-  hunkpriv_t *priv = NULL;
+  hunkpriv_t priv;
   switch (mode) {
   case kNluaXdiffModeUnified:
     luaL_buffinit(lstate, &buf);
@@ -296,14 +358,24 @@ int nlua_xdl_diff(lua_State *lstate)
     ecb.out_line = write_string;
     break;
   case kNluaXdiffModeOnHunkCB:
-    priv = xmalloc(sizeof(*priv));
-    priv->lstate = lstate;
-    priv->err = &err;
-    ecb.priv = priv;
+    cfg.hunk_func = call_on_hunk_cb;
+    priv = (hunkpriv_t) {
+      .lstate = lstate,
+      .err    = &err,
+    };
+    ecb.priv = &priv;
     break;
   case kNluaXdiffModeLocations:
+    cfg.hunk_func = hunk_locations_cb;
+    priv = (hunkpriv_t) {
+      .lstate    = lstate,
+      .ma        = &ma,
+      .mb        = &mb,
+      .linematch = linematch,
+      .iwhite    = (params.flags & XDF_IGNORE_WHITESPACE) > 0
+    };
+    ecb.priv = &priv;
     lua_createtable(lstate, 0, 0);
-    ecb.priv = lstate;
     break;
   }
 
@@ -314,8 +386,6 @@ int nlua_xdl_diff(lua_State *lstate)
     }
   }
 
-  XFREE_CLEAR(priv);
-
 exit_0:
   if (ERROR_SET(&err)) {
     luaL_where(lstate, 1);
-- 
cgit 


From f1c864cfe340dbb225caaf3dcbe28ee705be9f75 Mon Sep 17 00:00:00 2001
From: Lewis Russell <lewis6991@gmail.com>
Date: Fri, 4 Nov 2022 10:31:09 +0000
Subject: fix(diff): remove size_t underflow (#20929)

---
 src/nvim/lua/xdiff.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'src/nvim/lua')

diff --git a/src/nvim/lua/xdiff.c b/src/nvim/lua/xdiff.c
index 428a33cdad..ec7dc3c666 100644
--- a/src/nvim/lua/xdiff.c
+++ b/src/nvim/lua/xdiff.c
@@ -60,8 +60,8 @@ static void get_linematch_results(lua_State *lstate, mmfile_t *ma, mmfile_t *mb,
   const char *diff_begin[2] = { ma->ptr, mb->ptr };
   int diff_length[2] = { (int)count_a, (int)count_b };
 
-  fastforward_buf_to_lnum(&diff_begin[0], (size_t)start_a);
-  fastforward_buf_to_lnum(&diff_begin[1], (size_t)start_b);
+  fastforward_buf_to_lnum(&diff_begin[0], start_a);
+  fastforward_buf_to_lnum(&diff_begin[1], start_b);
 
   int *decisions = NULL;
   size_t decisions_length = linematch_nbuffers(diff_begin, diff_length, 2, &decisions, iwhite);
-- 
cgit 


From b854f2ce093de9593278b371de796f2ace044376 Mon Sep 17 00:00:00 2001
From: Lewis Russell <lewis6991@gmail.com>
Date: Fri, 4 Nov 2022 11:12:17 +0000
Subject: fix(vim.diff): correctly apply hunk offsets with linematch (#20931)

---
 src/nvim/lua/xdiff.c | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

(limited to 'src/nvim/lua')

diff --git a/src/nvim/lua/xdiff.c b/src/nvim/lua/xdiff.c
index ec7dc3c666..3adb6088fc 100644
--- a/src/nvim/lua/xdiff.c
+++ b/src/nvim/lua/xdiff.c
@@ -41,6 +41,15 @@ typedef struct {
 
 static void lua_pushhunk(lua_State *lstate, long start_a, long count_a, long start_b, long count_b)
 {
+  // Mimic extra offsets done by xdiff, see:
+  // src/xdiff/xemit.c:284
+  // src/xdiff/xutils.c:(356,368)
+  if (count_a > 0) {
+    start_a += 1;
+  }
+  if (count_b > 0) {
+    start_b += 1;
+  }
   lua_createtable(lstate, 0, 0);
   lua_pushinteger(lstate, start_a);
   lua_rawseti(lstate, -2, 1);
@@ -116,15 +125,6 @@ static int write_string(void *priv, mmbuffer_t *mb, int nbuf)
 // hunk_func callback used when opts.hunk_lines = true
 static int hunk_locations_cb(long start_a, long count_a, long start_b, long count_b, void *cb_data)
 {
-  // Mimic extra offsets done by xdiff, see:
-  // src/xdiff/xemit.c:284
-  // src/xdiff/xutils.c:(356,368)
-  if (count_a > 0) {
-    start_a += 1;
-  }
-  if (count_b > 0) {
-    start_b += 1;
-  }
   hunkpriv_t *priv = (hunkpriv_t *)cb_data;
   lua_State *lstate = priv->lstate;
   if (priv->linematch) {
-- 
cgit 


From 95f2f3cb5efcc18f17f2812ba6d1d9e1c06b2b5a Mon Sep 17 00:00:00 2001
From: Lewis Russell <lewis6991@gmail.com>
Date: Sat, 5 Nov 2022 00:58:01 +0000
Subject: fix(vim.diff): fix fastforward off-by-1 (#20937)

---
 src/nvim/lua/xdiff.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'src/nvim/lua')

diff --git a/src/nvim/lua/xdiff.c b/src/nvim/lua/xdiff.c
index 3adb6088fc..cd542b0e00 100644
--- a/src/nvim/lua/xdiff.c
+++ b/src/nvim/lua/xdiff.c
@@ -69,8 +69,8 @@ static void get_linematch_results(lua_State *lstate, mmfile_t *ma, mmfile_t *mb,
   const char *diff_begin[2] = { ma->ptr, mb->ptr };
   int diff_length[2] = { (int)count_a, (int)count_b };
 
-  fastforward_buf_to_lnum(&diff_begin[0], start_a);
-  fastforward_buf_to_lnum(&diff_begin[1], start_b);
+  fastforward_buf_to_lnum(&diff_begin[0], start_a + 1);
+  fastforward_buf_to_lnum(&diff_begin[1], start_b + 1);
 
   int *decisions = NULL;
   size_t decisions_length = linematch_nbuffers(diff_begin, diff_length, 2, &decisions, iwhite);
-- 
cgit 


From 731cdde28ea8d48cc23ba2752a08c261c87eee92 Mon Sep 17 00:00:00 2001
From: dundargoc <gocdundar@gmail.com>
Date: Sat, 22 Oct 2022 12:36:38 +0200
Subject: refactor: fix clang-tidy warnings

Enable and fix bugprone-misplaced-widening-cast warning.

Fix some modernize-macro-to-enum and readability-else-after-return
warnings, but don't enable them. While the warnings can be useful, they
are in general too noisy to enable.
---
 src/nvim/lua/converter.c |  3 +--
 src/nvim/lua/stdlib.c    | 15 +++++++--------
 2 files changed, 8 insertions(+), 10 deletions(-)

(limited to 'src/nvim/lua')

diff --git a/src/nvim/lua/converter.c b/src/nvim/lua/converter.c
index bdb0719809..d7881350aa 100644
--- a/src/nvim/lua/converter.c
+++ b/src/nvim/lua/converter.c
@@ -906,9 +906,8 @@ Float nlua_pop_Float(lua_State *lstate, Error *err)
   lua_pop(lstate, 1);
   if (table_props.type != kObjectTypeFloat) {
     return 0;
-  } else {
-    return (Float)table_props.val;
   }
+  return (Float)table_props.val;
 }
 
 /// Convert lua table to array without determining whether it is array
diff --git a/src/nvim/lua/stdlib.c b/src/nvim/lua/stdlib.c
index 6974c6181c..54e2c24523 100644
--- a/src/nvim/lua/stdlib.c
+++ b/src/nvim/lua/stdlib.c
@@ -378,15 +378,14 @@ int nlua_setvar(lua_State *lstate)
     if (di == NULL) {
       // Doesn't exist, nothing to do
       return 0;
-    } else {
-      // Notify watchers
-      if (watched) {
-        tv_dict_watcher_notify(dict, key.data, NULL, &di->di_tv);
-      }
-
-      // Delete the entry
-      tv_dict_item_remove(dict, di);
     }
+    // Notify watchers
+    if (watched) {
+      tv_dict_watcher_notify(dict, key.data, NULL, &di->di_tv);
+    }
+
+    // Delete the entry
+    tv_dict_item_remove(dict, di);
   } else {
     // Update the key
     typval_T tv;
-- 
cgit 


From c022140ec6a66402e405152054b6ab0141940419 Mon Sep 17 00:00:00 2001
From: Famiu Haque <famiuhaque@protonmail.com>
Date: Mon, 7 Nov 2022 22:27:37 +0600
Subject: feat(api): add command name to Lua command callback opts

Adds a `name` key to the opts dict passed to Lua command callbacks
created using `nvim_create_user_command()`. This is useful for when
multiple commands use the same callback.

Note that this kind of behavior is not as strange as one might think,
even some internal Neovim commands reuse the same internal C function,
differing their behavior by checking the command name. `substitute`,
`smagic` and `snomagic` are examples of that.

This will also be useful for generalized Lua command preview functions
that can preview a wide range of commands, in which case knowing the
command name is necessary for the preview function to actually be able
to execute the command that it's supposed to preview.
---
 src/nvim/lua/executor.c | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'src/nvim/lua')

diff --git a/src/nvim/lua/executor.c b/src/nvim/lua/executor.c
index 9d63fe55f9..9cb42a81d3 100644
--- a/src/nvim/lua/executor.c
+++ b/src/nvim/lua/executor.c
@@ -1985,6 +1985,9 @@ int nlua_do_ucmd(ucmd_T *cmd, exarg_T *eap, bool preview)
   nlua_pushref(lstate, preview ? cmd->uc_preview_luaref : cmd->uc_luaref);
 
   lua_newtable(lstate);
+  lua_pushstring(lstate, cmd->uc_name);
+  lua_setfield(lstate, -2, "name");
+
   lua_pushboolean(lstate, eap->forceit == 1);
   lua_setfield(lstate, -2, "bang");
 
-- 
cgit 


From 2755510f7800ff675a5fbe2cfaa59459ff3ab6b2 Mon Sep 17 00:00:00 2001
From: dundargoc <gocdundar@gmail.com>
Date: Sat, 12 Nov 2022 13:34:14 +0100
Subject: ci(windows): treat compiler warnings as errors

Reduce the warning level from 3 to 1 and fix all warnings.
---
 src/nvim/lua/executor.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/nvim/lua')

diff --git a/src/nvim/lua/executor.c b/src/nvim/lua/executor.c
index 9cb42a81d3..c27df01342 100644
--- a/src/nvim/lua/executor.c
+++ b/src/nvim/lua/executor.c
@@ -585,7 +585,7 @@ static bool nlua_init_packages(lua_State *lstate)
   lua_getglobal(lstate, "require");
   lua_pushstring(lstate, "vim._init_packages");
   if (nlua_pcall(lstate, 1, 0)) {
-    mch_errmsg(lua_tostring(lstate, -1));
+    mch_errmsg((char *)lua_tostring(lstate, -1));
     mch_errmsg("\n");
     return false;
   }
-- 
cgit 


From 66360675cf4d091b7460e4a8e1435c13216c1929 Mon Sep 17 00:00:00 2001
From: dundargoc <gocdundar@gmail.com>
Date: Sun, 11 Sep 2022 17:12:44 +0200
Subject: build: allow IWYU to fix includes for all .c files

Allow Include What You Use to remove unnecessary includes and only
include what is necessary. This helps with reducing compilation times
and makes it easier to visualise which dependencies are actually
required.

Work on https://github.com/neovim/neovim/issues/549, but doesn't close
it since this only works fully for .c files and not headers.
---
 src/nvim/lua/converter.c  | 13 +++++++++----
 src/nvim/lua/executor.c   | 25 +++++++++++++++++++------
 src/nvim/lua/executor.h   |  4 ++++
 src/nvim/lua/spell.c      | 16 +++++++++++++---
 src/nvim/lua/stdlib.c     | 39 ++++++++++++++-------------------------
 src/nvim/lua/treesitter.c | 13 +++++++++----
 src/nvim/lua/xdiff.c      |  9 +++++----
 7 files changed, 73 insertions(+), 46 deletions(-)

(limited to 'src/nvim/lua')

diff --git a/src/nvim/lua/converter.c b/src/nvim/lua/converter.c
index d7881350aa..3c129fe7ce 100644
--- a/src/nvim/lua/converter.c
+++ b/src/nvim/lua/converter.c
@@ -4,14 +4,14 @@
 #include <assert.h>
 #include <lauxlib.h>
 #include <lua.h>
-#include <lualib.h>
 #include <stdbool.h>
+#include <stddef.h>
 #include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
 
 #include "nvim/api/private/defs.h"
 #include "nvim/api/private/helpers.h"
-#include "nvim/assert.h"
-#include "nvim/func_attr.h"
 #include "nvim/memory.h"
 // FIXME: vim.h is not actually needed, but otherwise it states MAXPATHL is
 //        redefined
@@ -19,12 +19,16 @@
 #include "nvim/ascii.h"
 #include "nvim/eval/decode.h"
 #include "nvim/eval/typval.h"
+#include "nvim/eval/typval_defs.h"
+#include "nvim/eval/typval_encode.h"
 #include "nvim/eval/userfunc.h"
-#include "nvim/globals.h"
+#include "nvim/garray.h"
+#include "nvim/gettext.h"
 #include "nvim/lua/converter.h"
 #include "nvim/lua/executor.h"
 #include "nvim/macros.h"
 #include "nvim/message.h"
+#include "nvim/types.h"
 #include "nvim/vim.h"
 
 /// Determine, which keys lua table contains
@@ -565,6 +569,7 @@ static bool typval_conv_special = false;
 #define TYPVAL_ENCODE_FIRST_ARG_TYPE lua_State *const
 #define TYPVAL_ENCODE_FIRST_ARG_NAME lstate
 #include "nvim/eval/typval_encode.c.h"
+
 #undef TYPVAL_ENCODE_SCOPE
 #undef TYPVAL_ENCODE_NAME
 #undef TYPVAL_ENCODE_FIRST_ARG_TYPE
diff --git a/src/nvim/lua/executor.c b/src/nvim/lua/executor.c
index 9cb42a81d3..d2c2f932ec 100644
--- a/src/nvim/lua/executor.c
+++ b/src/nvim/lua/executor.c
@@ -1,18 +1,22 @@
 // This is an open source non-commercial project. Dear PVS-Studio, please check
 // it. PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
 
+#include <assert.h>
+#include <inttypes.h>
 #include <lauxlib.h>
 #include <lua.h>
 #include <lualib.h>
+#include <stddef.h>
+#include <string.h>
 #include <tree_sitter/api.h>
+#include <uv.h>
 
+#include "klib/kvec.h"
 #include "luv/luv.h"
 #include "nvim/api/extmark.h"
 #include "nvim/api/private/defs.h"
 #include "nvim/api/private/helpers.h"
-#include "nvim/api/vim.h"
 #include "nvim/ascii.h"
-#include "nvim/assert.h"
 #include "nvim/buffer_defs.h"
 #include "nvim/change.h"
 #include "nvim/cursor.h"
@@ -20,28 +24,37 @@
 #include "nvim/eval.h"
 #include "nvim/eval/funcs.h"
 #include "nvim/eval/typval.h"
+#include "nvim/eval/typval_defs.h"
 #include "nvim/eval/userfunc.h"
+#include "nvim/event/defs.h"
 #include "nvim/event/loop.h"
+#include "nvim/event/multiqueue.h"
 #include "nvim/event/time.h"
 #include "nvim/ex_cmds.h"
+#include "nvim/ex_cmds_defs.h"
 #include "nvim/ex_getln.h"
-#include "nvim/extmark.h"
-#include "nvim/func_attr.h"
 #include "nvim/garray.h"
 #include "nvim/getchar.h"
+#include "nvim/gettext.h"
+#include "nvim/globals.h"
+#include "nvim/keycodes.h"
 #include "nvim/lua/converter.h"
 #include "nvim/lua/executor.h"
 #include "nvim/lua/stdlib.h"
 #include "nvim/lua/treesitter.h"
 #include "nvim/macros.h"
-#include "nvim/map.h"
+#include "nvim/main.h"
 #include "nvim/memline.h"
+#include "nvim/memory.h"
 #include "nvim/message.h"
 #include "nvim/msgpack_rpc/channel.h"
+#include "nvim/option_defs.h"
 #include "nvim/os/os.h"
+#include "nvim/path.h"
+#include "nvim/pos.h"
 #include "nvim/profile.h"
 #include "nvim/runtime.h"
-#include "nvim/screen.h"
+#include "nvim/strings.h"
 #include "nvim/ui.h"
 #include "nvim/ui_compositor.h"
 #include "nvim/undo.h"
diff --git a/src/nvim/lua/executor.h b/src/nvim/lua/executor.h
index 78346fd81f..c6747833e5 100644
--- a/src/nvim/lua/executor.h
+++ b/src/nvim/lua/executor.h
@@ -3,13 +3,17 @@
 
 #include <lauxlib.h>
 #include <lua.h>
+#include <stdbool.h>
 
 #include "nvim/api/private/defs.h"
+#include "nvim/api/private/helpers.h"
 #include "nvim/assert.h"
 #include "nvim/eval/typval.h"
 #include "nvim/ex_cmds_defs.h"
 #include "nvim/func_attr.h"
 #include "nvim/lua/converter.h"
+#include "nvim/macros.h"
+#include "nvim/types.h"
 #include "nvim/usercmd.h"
 
 // Generated by msgpack-gen.lua
diff --git a/src/nvim/lua/spell.c b/src/nvim/lua/spell.c
index 31a2b2d19f..0a566b2f86 100644
--- a/src/nvim/lua/spell.c
+++ b/src/nvim/lua/spell.c
@@ -1,15 +1,25 @@
 // This is an open source non-commercial project. Dear PVS-Studio, please check
 // it. PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
 
+#include <assert.h>
 #include <lauxlib.h>
+#include <limits.h>
 #include <lua.h>
-
+#include <stdbool.h>
+#include <stddef.h>
+
+#include "nvim/ascii.h"
+#include "nvim/buffer_defs.h"
+#include "nvim/gettext.h"
+#include "nvim/globals.h"
+#include "nvim/highlight_defs.h"
 #include "nvim/lua/spell.h"
+#include "nvim/message.h"
 #include "nvim/spell.h"
-#include "nvim/vim.h"
+#include "nvim/types.h"
 
 #ifdef INCLUDE_GENERATED_DECLARATIONS
-# include "lua/spell.c.generated.h"
+# include "lua/spell.c.generated.h"  // IWYU pragma: export
 #endif
 
 int nlua_spell_check(lua_State *lstate)
diff --git a/src/nvim/lua/stdlib.c b/src/nvim/lua/stdlib.c
index 54e2c24523..813f86eeee 100644
--- a/src/nvim/lua/stdlib.c
+++ b/src/nvim/lua/stdlib.c
@@ -1,50 +1,39 @@
 // This is an open source non-commercial project. Dear PVS-Studio, please check
 // it. PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
 
+#include <assert.h>
 #include <lauxlib.h>
 #include <lua.h>
-#include <lualib.h>
-
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+#include <sys/types.h>
+
+#include "auto/config.h"
 #include "cjson/lua_cjson.h"
-#include "luv/luv.h"
 #include "mpack/lmpack.h"
 #include "nvim/api/private/defs.h"
 #include "nvim/api/private/helpers.h"
-#include "nvim/api/vim.h"
 #include "nvim/ascii.h"
-#include "nvim/assert.h"
 #include "nvim/buffer_defs.h"
-#include "nvim/change.h"
-#include "nvim/cursor.h"
 #include "nvim/eval.h"
-#include "nvim/eval/userfunc.h"
-#include "nvim/event/loop.h"
-#include "nvim/event/time.h"
+#include "nvim/eval/typval.h"
+#include "nvim/eval/typval_defs.h"
 #include "nvim/ex_eval.h"
-#include "nvim/ex_getln.h"
-#include "nvim/extmark.h"
-#include "nvim/func_attr.h"
-#include "nvim/garray.h"
-#include "nvim/getchar.h"
 #include "nvim/globals.h"
 #include "nvim/lua/converter.h"
-#include "nvim/lua/executor.h"
 #include "nvim/lua/spell.h"
 #include "nvim/lua/stdlib.h"
-#include "nvim/lua/treesitter.h"
 #include "nvim/lua/xdiff.h"
-#include "nvim/macros.h"
 #include "nvim/map.h"
+#include "nvim/mbyte.h"
 #include "nvim/memline.h"
-#include "nvim/message.h"
-#include "nvim/msgpack_rpc/channel.h"
-#include "nvim/os/os.h"
+#include "nvim/memory.h"
+#include "nvim/pos.h"
 #include "nvim/regexp.h"
-#include "nvim/regexp_defs.h"
-#include "nvim/screen.h"
 #include "nvim/types.h"
-#include "nvim/undo.h"
-#include "nvim/version.h"
 #include "nvim/vim.h"
 
 #ifdef INCLUDE_GENERATED_DECLARATIONS
diff --git a/src/nvim/lua/treesitter.c b/src/nvim/lua/treesitter.c
index 9d871939f8..d77e210c6a 100644
--- a/src/nvim/lua/treesitter.c
+++ b/src/nvim/lua/treesitter.c
@@ -6,23 +6,28 @@
 // trees and nodes, and could be broken out as a reusable lua package
 
 #include <assert.h>
-#include <inttypes.h>
 #include <lauxlib.h>
+#include <limits.h>
 #include <lua.h>
-#include <lualib.h>
 #include <stdbool.h>
 #include <stdint.h>
+#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <uv.h>
 
 #include "klib/kvec.h"
 #include "nvim/api/private/helpers.h"
-#include "nvim/buffer.h"
-#include "nvim/log.h"
+#include "nvim/buffer_defs.h"
+#include "nvim/globals.h"
 #include "nvim/lua/treesitter.h"
+#include "nvim/macros.h"
 #include "nvim/map.h"
 #include "nvim/memline.h"
+#include "nvim/memory.h"
+#include "nvim/pos.h"
+#include "nvim/strings.h"
+#include "nvim/types.h"
 #include "tree_sitter/api.h"
 
 #define TS_META_PARSER "treesitter_parser"
diff --git a/src/nvim/lua/xdiff.c b/src/nvim/lua/xdiff.c
index cd542b0e00..857b159af5 100644
--- a/src/nvim/lua/xdiff.c
+++ b/src/nvim/lua/xdiff.c
@@ -1,19 +1,20 @@
 // This is an open source non-commercial project. Dear PVS-Studio, please check
 // it. PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
 
-#include <errno.h>
 #include <lauxlib.h>
 #include <lua.h>
-#include <lualib.h>
-#include <stdio.h>
-#include <stdlib.h>
+#include <stdbool.h>
 #include <string.h>
 
+#include "luaconf.h"
+#include "nvim/api/private/defs.h"
 #include "nvim/api/private/helpers.h"
 #include "nvim/linematch.h"
 #include "nvim/lua/converter.h"
 #include "nvim/lua/executor.h"
 #include "nvim/lua/xdiff.h"
+#include "nvim/macros.h"
+#include "nvim/memory.h"
 #include "nvim/vim.h"
 #include "xdiff/xdiff.h"
 
-- 
cgit 


From 294910a1ffd11bea0081c2b92632628ef0462eb1 Mon Sep 17 00:00:00 2001
From: Gregory Anders <greg@gpanders.com>
Date: Sat, 5 Nov 2022 19:30:48 -0600
Subject: feat(exrc): use vim.secure.read() for 'exrc' option

---
 src/nvim/lua/executor.c | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

(limited to 'src/nvim/lua')

diff --git a/src/nvim/lua/executor.c b/src/nvim/lua/executor.c
index 79cc3ed112..43a3b12a98 100644
--- a/src/nvim/lua/executor.c
+++ b/src/nvim/lua/executor.c
@@ -2193,3 +2193,27 @@ plain:
   kv_printf(str, "<Lua %d>", ref);
   return str.items;
 }
+
+char *nlua_read_secure(const char *path)
+{
+  lua_State *const lstate = global_lstate;
+  lua_getglobal(lstate, "vim");
+  lua_getfield(lstate, -1, "secure");
+  lua_getfield(lstate, -1, "read");
+  lua_pushstring(lstate, path);
+  lua_call(lstate, 1, 1);
+
+  size_t len = 0;
+  const char *contents = lua_tolstring(lstate, -1, &len);
+  char *buf = NULL;
+  if (contents != NULL) {
+    // Add one to include trailing null byte
+    buf = xcalloc(len + 1, sizeof(char));
+    memcpy(buf, contents, len + 1);
+  }
+
+  // Pop return value, "vim", and "secure"
+  lua_pop(lstate, 3);
+
+  return buf;
+}
-- 
cgit 


From f004812b338340e5f5157aa68d09d3f0e5605c6c Mon Sep 17 00:00:00 2001
From: Jlll1 <arghantentua@tutanota.com>
Date: Mon, 28 Nov 2022 20:23:04 +0100
Subject: feat(secure): add `:trust` command  and vim.secure.trust() (#21107)

Introduce vim.secure.trust() to programmatically manage the trust
database. Use this function in a new :trust ex command which can
be used as a simple frontend.

Resolves: https://github.com/neovim/neovim/issues/21092
Co-authored-by: Gregory Anders <greg@gpanders.com>
Co-authored-by: ii14 <ii14@users.noreply.github.com>
---
 src/nvim/lua/executor.c | 48 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 48 insertions(+)

(limited to 'src/nvim/lua')

diff --git a/src/nvim/lua/executor.c b/src/nvim/lua/executor.c
index 43a3b12a98..5380559baf 100644
--- a/src/nvim/lua/executor.c
+++ b/src/nvim/lua/executor.c
@@ -2217,3 +2217,51 @@ char *nlua_read_secure(const char *path)
 
   return buf;
 }
+
+bool nlua_trust(const char *action, const char *path)
+{
+  lua_State *const lstate = global_lstate;
+  lua_getglobal(lstate, "vim");
+  lua_getfield(lstate, -1, "secure");
+  lua_getfield(lstate, -1, "trust");
+
+  lua_newtable(lstate);
+  lua_pushstring(lstate, "action");
+  lua_pushstring(lstate, action);
+  lua_settable(lstate, -3);
+  if (path == NULL) {
+    lua_pushstring(lstate, "bufnr");
+    lua_pushnumber(lstate, 0);
+    lua_settable(lstate, -3);
+  } else {
+    lua_pushstring(lstate, "path");
+    lua_pushstring(lstate, path);
+    lua_settable(lstate, -3);
+  }
+
+  if (nlua_pcall(lstate, 1, 2)) {
+    nlua_error(lstate, _("Error executing vim.secure.trust: %.*s"));
+    return false;
+  }
+
+  bool success = lua_toboolean(lstate, -2);
+  const char *msg = lua_tostring(lstate, -1);
+  if (msg != NULL) {
+    if (success) {
+      if (strcmp(action, "allow") == 0) {
+        smsg("Allowed \"%s\" in trust database.", msg);
+      } else if (strcmp(action, "deny") == 0) {
+        smsg("Denied \"%s\" in trust database.", msg);
+      } else if (strcmp(action, "remove") == 0) {
+        smsg("Removed \"%s\" from trust database.", msg);
+      }
+    } else {
+      semsg(e_trustfile, msg);
+    }
+  }
+
+  // Pop return values, "vim" and "secure"
+  lua_pop(lstate, 4);
+
+  return success;
+}
-- 
cgit 


From 2ae0d32a72c3ee207b6f9cd48c4beffa6e7c774f Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Sat, 3 Dec 2022 08:24:22 +0800
Subject: refactor: make sure getting a callback doesn't modify argument

---
 src/nvim/lua/executor.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'src/nvim/lua')

diff --git a/src/nvim/lua/executor.c b/src/nvim/lua/executor.c
index 5380559baf..48ab2e3d70 100644
--- a/src/nvim/lua/executor.c
+++ b/src/nvim/lua/executor.c
@@ -1845,7 +1845,7 @@ static int nlua_is_thread(lua_State *lstate)
   return 1;
 }
 
-bool nlua_is_table_from_lua(typval_T *const arg)
+bool nlua_is_table_from_lua(const typval_T *const arg)
 {
   if (arg->v_type == VAR_DICT) {
     return arg->vval.v_dict->lua_table_ref != LUA_NOREF;
@@ -1856,7 +1856,7 @@ bool nlua_is_table_from_lua(typval_T *const arg)
   }
 }
 
-char_u *nlua_register_table_as_callable(typval_T *const arg)
+char_u *nlua_register_table_as_callable(const typval_T *const arg)
 {
   LuaRef table_ref = LUA_NOREF;
   if (arg->v_type == VAR_DICT) {
-- 
cgit 


From f3bf1fbf600050fde155e6a1a766b6f848012208 Mon Sep 17 00:00:00 2001
From: ii14 <59243201+ii14@users.noreply.github.com>
Date: Mon, 5 Dec 2022 19:59:04 +0100
Subject: fix(secure): crash when hitting escape in prompt (#21283)

- use pcall when calling vim.secure.read from C
- catch keyboard interrupts in vim.secure.read, rethrow other errors
- selecting "view" in prompt runs :view command
- simplify lua stack cleanup with lua_gettop and lua_settop

Co-authored-by: ii14 <ii14@users.noreply.github.com>
---
 src/nvim/lua/executor.c | 19 ++++++++++++-------
 1 file changed, 12 insertions(+), 7 deletions(-)

(limited to 'src/nvim/lua')

diff --git a/src/nvim/lua/executor.c b/src/nvim/lua/executor.c
index 48ab2e3d70..1c8fe3e28e 100644
--- a/src/nvim/lua/executor.c
+++ b/src/nvim/lua/executor.c
@@ -2197,11 +2197,17 @@ plain:
 char *nlua_read_secure(const char *path)
 {
   lua_State *const lstate = global_lstate;
+  const int top = lua_gettop(lstate);
+
   lua_getglobal(lstate, "vim");
   lua_getfield(lstate, -1, "secure");
   lua_getfield(lstate, -1, "read");
   lua_pushstring(lstate, path);
-  lua_call(lstate, 1, 1);
+  if (nlua_pcall(lstate, 1, 1)) {
+    nlua_error(lstate, _("Error executing vim.secure.read: %.*s"));
+    lua_settop(lstate, top);
+    return NULL;
+  }
 
   size_t len = 0;
   const char *contents = lua_tolstring(lstate, -1, &len);
@@ -2212,15 +2218,15 @@ char *nlua_read_secure(const char *path)
     memcpy(buf, contents, len + 1);
   }
 
-  // Pop return value, "vim", and "secure"
-  lua_pop(lstate, 3);
-
+  lua_settop(lstate, top);
   return buf;
 }
 
 bool nlua_trust(const char *action, const char *path)
 {
   lua_State *const lstate = global_lstate;
+  const int top = lua_gettop(lstate);
+
   lua_getglobal(lstate, "vim");
   lua_getfield(lstate, -1, "secure");
   lua_getfield(lstate, -1, "trust");
@@ -2241,6 +2247,7 @@ bool nlua_trust(const char *action, const char *path)
 
   if (nlua_pcall(lstate, 1, 2)) {
     nlua_error(lstate, _("Error executing vim.secure.trust: %.*s"));
+    lua_settop(lstate, top);
     return false;
   }
 
@@ -2260,8 +2267,6 @@ bool nlua_trust(const char *action, const char *path)
     }
   }
 
-  // Pop return values, "vim" and "secure"
-  lua_pop(lstate, 4);
-
+  lua_settop(lstate, top);
   return success;
 }
-- 
cgit 


From 614d382621fa0b9d19287b63edb39b637409c581 Mon Sep 17 00:00:00 2001
From: "Justin M. Keyes" <justinkz@gmail.com>
Date: Fri, 16 Dec 2022 17:33:52 +0100
Subject: refactor: rename mch_msg => os_msg

---
 src/nvim/lua/executor.c | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

(limited to 'src/nvim/lua')

diff --git a/src/nvim/lua/executor.c b/src/nvim/lua/executor.c
index 1c8fe3e28e..590d6fa920 100644
--- a/src/nvim/lua/executor.c
+++ b/src/nvim/lua/executor.c
@@ -205,8 +205,8 @@ static int nlua_luv_cfpcall(lua_State *lstate, int nargs, int nresult, int flags
   if (status) {
     if (status == LUA_ERRMEM && !(flags & LUVF_CALLBACK_NOEXIT)) {
       // consider out of memory errors unrecoverable, just like xmalloc()
-      mch_errmsg(e_outofmem);
-      mch_errmsg("\n");
+      os_errmsg(e_outofmem);
+      os_errmsg("\n");
       preserve_exit();
     }
     const char *error = lua_tostring(lstate, -1);
@@ -258,8 +258,8 @@ static int nlua_luv_thread_common_cfpcall(lua_State *lstate, int nargs, int nres
     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");
+      os_errmsg(e_outofmem);
+      os_errmsg("\n");
       lua_close(lstate);
 #ifdef MSWIN
       ExitThread(0);
@@ -598,8 +598,8 @@ static bool nlua_init_packages(lua_State *lstate)
   lua_getglobal(lstate, "require");
   lua_pushstring(lstate, "vim._init_packages");
   if (nlua_pcall(lstate, 1, 0)) {
-    mch_errmsg((char *)lua_tostring(lstate, -1));
-    mch_errmsg("\n");
+    os_errmsg((char *)lua_tostring(lstate, -1));
+    os_errmsg("\n");
     return false;
   }
 
@@ -779,12 +779,12 @@ void nlua_init(void)
 
   lua_State *lstate = luaL_newstate();
   if (lstate == NULL) {
-    mch_errmsg(_("E970: Failed to initialize lua interpreter\n"));
+    os_errmsg(_("E970: Failed to initialize lua interpreter\n"));
     os_exit(1);
   }
   luaL_openlibs(lstate);
   if (!nlua_state_init(lstate)) {
-    mch_errmsg(_("E970: Failed to initialize builtin lua modules\n"));
+    os_errmsg(_("E970: Failed to initialize builtin lua modules\n"));
     os_exit(1);
   }
 
-- 
cgit 


From b2295ac4ec80e141628cea33ebee81c96e168989 Mon Sep 17 00:00:00 2001
From: bfredl <bjorn.linse@gmail.com>
Date: Tue, 3 Jan 2023 15:24:41 +0100
Subject: refactor(api): do not allocate temporaries for internal events

---
 src/nvim/lua/executor.c | 1 +
 1 file changed, 1 insertion(+)

(limited to 'src/nvim/lua')

diff --git a/src/nvim/lua/executor.c b/src/nvim/lua/executor.c
index 590d6fa920..d4e7f3fb2c 100644
--- a/src/nvim/lua/executor.c
+++ b/src/nvim/lua/executor.c
@@ -1190,6 +1190,7 @@ static int nlua_rpc(lua_State *lstate, bool request)
       api_set_error(&err, kErrorTypeValidation,
                     "Invalid channel: %" PRIu64, chan_id);
     }
+    api_free_array(args);  // TODO(bfredl): no
   }
 
 check_err:
-- 
cgit 


From 47ba78f89a1f0bba8168b4408bc55a3024d5ab97 Mon Sep 17 00:00:00 2001
From: bfredl <bjorn.linse@gmail.com>
Date: Fri, 30 Dec 2022 22:17:01 +0100
Subject: refactor(ui): devirtualize the ui layer

- The defined interface for the UI is only the RPC protocol. The original
  UI interface as an array of function pointers fill no function.
- On the server, all the UI:s are all RPC channels.
  - ui.c is only used on the server.
  - The compositor is a preprocessing step for single-grid UI:s
- on the client, ui_client and tui talk directly to each other
  - we still do module separation, as ui_client.c could form the basis
    of a libnvim client module later.

Items for later PR:s
- vim.ui_attach is still an unhappy child, reconsider based on plugin experience.
- the flags in ui_events.in.h are still a mess. Can be simplified now.
- UX for remote attachment needs more work.
- startup for client can be simplified further (think of the millisecs we can save)
---
 src/nvim/lua/executor.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'src/nvim/lua')

diff --git a/src/nvim/lua/executor.c b/src/nvim/lua/executor.c
index d4e7f3fb2c..34b572f884 100644
--- a/src/nvim/lua/executor.c
+++ b/src/nvim/lua/executor.c
@@ -653,7 +653,7 @@ ok:
   }
 
   LuaRef ui_event_cb = nlua_ref_global(lstate, 3);
-  ui_comp_add_cb(ns_id, ui_event_cb, ext_widgets);
+  ui_add_cb(ns_id, ui_event_cb, ext_widgets);
   return 0;
 }
 
@@ -667,7 +667,7 @@ static int nlua_ui_detach(lua_State *lstate)
     return luaL_error(lstate, "invalid ns_id");
   }
 
-  ui_comp_remove_cb(ns_id);
+  ui_remove_cb(ns_id);
   return 0;
 }
 
-- 
cgit 


From 7c94bcd2d77e2e54b8836ab8325460a367b79eae Mon Sep 17 00:00:00 2001
From: "Justin M. Keyes" <justinkz@gmail.com>
Date: Mon, 20 Sep 2021 19:00:50 -0700
Subject: feat(lua)!: execute Lua with "nvim -l"

Problem:
Nvim has Lua but the "nvim" CLI can't easily be used to execute Lua
scripts, especially scripts that take arguments or produce output.

Solution:
- support "nvim -l [args...]" for running scripts. closes #15749
- exit without +q
- remove lua2dox_filter
- remove Doxyfile. This wasn't used anyway, because the doxygen config
  is inlined in gen_vimdoc.py (`Doxyfile` variable).
- use "nvim -l" in docs-gen CI job

Examples:

    $ nvim -l scripts/lua2dox.lua --help
    Lua2DoX (0.2 20130128)
    ...

    $ echo "print(vim.inspect(_G.arg))" | nvim -l - --arg1 --arg2
    $ echo 'print(vim.inspect(vim.api.nvim_buf_get_text(1,0,0,-1,-1,{})))' | nvim +"put ='text'" -l -

TODO?
  -e executes Lua code
  -l loads a module
  -i enters REPL _after running the other arguments_.
---
 src/nvim/lua/executor.c | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)

(limited to 'src/nvim/lua')

diff --git a/src/nvim/lua/executor.c b/src/nvim/lua/executor.c
index 34b572f884..1bedb70efb 100644
--- a/src/nvim/lua/executor.c
+++ b/src/nvim/lua/executor.c
@@ -323,6 +323,34 @@ static int nlua_thr_api_nvim__get_runtime(lua_State *lstate)
   return 1;
 }
 
+/// Copies all args into the Lua `arg` global.
+///
+/// Example:
+///     nvim -l foo.lua -- -e "sin=math.sin" script a b
+///
+/// @note `lua` CLI sets _negative_ `arg` indices to the arguments upto "-e".
+///
+/// @see https://www.lua.org/pil/1.4.html
+/// @see https://github.com/premake/premake-core/blob/1c1304637f4f5e50ba8c57aae8d1d80ec3b7aaf2/src/host/premake.c#L563-L594
+///
+/// @returns number of args (stops at "--")
+int nlua_set_argv(char **argv, int argc)
+{
+  lua_State *const L = global_lstate;
+  lua_newtable(L);
+  int i = 0;
+  for (; i < argc; i++) {
+    if (strequal("--", argv[i])) {
+      i--;
+      break;
+    }
+    lua_pushstring(L, argv[i]);
+    lua_rawseti(L, -2, i + 1);
+  }
+  lua_setglobal(L, "arg");
+  return i + 1;
+}
+
 static void nlua_schedule_event(void **argv)
 {
   LuaRef cb = (LuaRef)(ptrdiff_t)argv[0];
-- 
cgit 


From 45549f031ee52a01601c33acc411f3111cfc4e95 Mon Sep 17 00:00:00 2001
From: "Justin M. Keyes" <justinkz@gmail.com>
Date: Sun, 1 Jan 2023 03:14:13 +0100
Subject: feat(lua): send "--" literally to Lua "-l" script

Problem:
When "-l" is followed by "--", we stop sending args to the Lua script
and treat "--" in the usual way. This was for flexibility but didn't
have a strong use-case, and has these problems:
- prevents Lua "-l" scripts from handling "--" in their own way.
- complicates the startup logic (must call nlua_init before command_line_scan)

Solution:
Don't treat "--" specially if it follows "-l".
---
 src/nvim/lua/executor.c | 22 +++++++++-------------
 1 file changed, 9 insertions(+), 13 deletions(-)

(limited to 'src/nvim/lua')

diff --git a/src/nvim/lua/executor.c b/src/nvim/lua/executor.c
index 1bedb70efb..20c901004a 100644
--- a/src/nvim/lua/executor.c
+++ b/src/nvim/lua/executor.c
@@ -323,32 +323,28 @@ static int nlua_thr_api_nvim__get_runtime(lua_State *lstate)
   return 1;
 }
 
-/// Copies all args into the Lua `arg` global.
+/// Copies args starting at `lua_arg0` into the Lua `arg` global.
 ///
 /// Example:
-///     nvim -l foo.lua -- -e "sin=math.sin" script a b
+///     nvim -l foo.lua --arg1 --arg2
 ///
 /// @note `lua` CLI sets _negative_ `arg` indices to the arguments upto "-e".
 ///
 /// @see https://www.lua.org/pil/1.4.html
 /// @see https://github.com/premake/premake-core/blob/1c1304637f4f5e50ba8c57aae8d1d80ec3b7aaf2/src/host/premake.c#L563-L594
 ///
-/// @returns number of args (stops at "--")
-int nlua_set_argv(char **argv, int argc)
+/// @returns number of args
+int nlua_set_argv(char **argv, int argc, int lua_arg0)
 {
   lua_State *const L = global_lstate;
-  lua_newtable(L);
+  lua_newtable(L);  // _G.arg
   int i = 0;
-  for (; i < argc; i++) {
-    if (strequal("--", argv[i])) {
-      i--;
-      break;
-    }
-    lua_pushstring(L, argv[i]);
-    lua_rawseti(L, -2, i + 1);
+  for (; lua_arg0 >= 0 && i + lua_arg0 < argc; i++) {
+    lua_pushstring(L, argv[i + lua_arg0]);
+    lua_rawseti(L, -2, i + 1);  // _G.arg[i+1] = "arg1"
   }
   lua_setglobal(L, "arg");
-  return i + 1;
+  return i;
 }
 
 static void nlua_schedule_event(void **argv)
-- 
cgit 


From adef308a5925a3b967af3bd7c598074e5b6cae18 Mon Sep 17 00:00:00 2001
From: "Justin M. Keyes" <justinkz@gmail.com>
Date: Mon, 2 Jan 2023 15:34:14 +0100
Subject: feat(lua): exit 1 on Lua "-l" script error

---
 src/nvim/lua/executor.c | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

(limited to 'src/nvim/lua')

diff --git a/src/nvim/lua/executor.c b/src/nvim/lua/executor.c
index 20c901004a..4b08603dd0 100644
--- a/src/nvim/lua/executor.c
+++ b/src/nvim/lua/executor.c
@@ -325,10 +325,11 @@ static int nlua_thr_api_nvim__get_runtime(lua_State *lstate)
 
 /// Copies args starting at `lua_arg0` into the Lua `arg` global.
 ///
-/// Example:
+/// Example (`lua_arg0` points to "--arg1"):
 ///     nvim -l foo.lua --arg1 --arg2
 ///
-/// @note `lua` CLI sets _negative_ `arg` indices to the arguments upto "-e".
+/// @note Lua CLI sets arguments upto "-e" as _negative_ `_G.arg` indices, but we currently don't
+/// follow that convention.
 ///
 /// @see https://www.lua.org/pil/1.4.html
 /// @see https://github.com/premake/premake-core/blob/1c1304637f4f5e50ba8c57aae8d1d80ec3b7aaf2/src/host/premake.c#L563-L594
@@ -1710,10 +1711,10 @@ void ex_luafile(exarg_T *const eap)
   nlua_exec_file((const char *)eap->arg);
 }
 
-/// execute lua code from a file.
+/// Executes 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.
+/// Note: we call the Lua global loadfile as opposed to calling luaL_loadfile
+/// in case loadfile was overridden in the user's environment.
 ///
 /// @param  path  path of the file
 ///
-- 
cgit 


From f43de742e881e54a3602e00c8c247cecca65a266 Mon Sep 17 00:00:00 2001
From: "Justin M. Keyes" <justinkz@gmail.com>
Date: Tue, 3 Jan 2023 02:54:53 +0100
Subject: feat(lua): execute stdin ("-") as Lua

---
 src/nvim/lua/executor.c | 57 ++++++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 49 insertions(+), 8 deletions(-)

(limited to 'src/nvim/lua')

diff --git a/src/nvim/lua/executor.c b/src/nvim/lua/executor.c
index 4b08603dd0..b7844363c5 100644
--- a/src/nvim/lua/executor.c
+++ b/src/nvim/lua/executor.c
@@ -335,7 +335,7 @@ static int nlua_thr_api_nvim__get_runtime(lua_State *lstate)
 /// @see https://github.com/premake/premake-core/blob/1c1304637f4f5e50ba8c57aae8d1d80ec3b7aaf2/src/host/premake.c#L563-L594
 ///
 /// @returns number of args
-int nlua_set_argv(char **argv, int argc, int lua_arg0)
+int nlua_init_argv(char **argv, int argc, int lua_arg0)
 {
   lua_State *const L = global_lstate;
   lua_newtable(L);  // _G.arg
@@ -1711,21 +1711,62 @@ void ex_luafile(exarg_T *const eap)
   nlua_exec_file((const char *)eap->arg);
 }
 
-/// Executes Lua code from a file.
+/// Executes Lua code from a file or "-" (stdin).
 ///
-/// Note: we call the Lua global loadfile as opposed to calling luaL_loadfile
-/// in case loadfile was overridden in the user's environment.
+/// Calls the Lua `loadfile` global as opposed to `luaL_loadfile` in case `loadfile` was overridden
+/// in the user environment.
 ///
-/// @param  path  path of the file
+/// @param path Path to the file, may be "-" (stdin) during startup.
 ///
-/// @return  true if everything ok, false if there was an error (echoed)
+/// @return true on success, false on error (echoed) or user canceled (CTRL-c) while reading "-"
+/// (stdin).
 bool nlua_exec_file(const char *path)
   FUNC_ATTR_NONNULL_ALL
 {
   lua_State *const lstate = global_lstate;
+  if (!strequal(path, "-")) {
+    lua_getglobal(lstate, "loadfile");
+    lua_pushstring(lstate, path);
+  } else {
+    int error;
+    int stdin_dup_fd;
+    if (stdin_fd > 0) {
+      stdin_dup_fd = stdin_fd;
+    } else {
+      stdin_dup_fd = os_dup(STDIN_FILENO);
+#ifdef MSWIN
+      // Replace the original stdin with the console input handle.
+      os_replace_stdin_to_conin();
+#endif
+    }
+    FileDescriptor *const stdin_dup = file_open_fd_new(&error, stdin_dup_fd,
+                                                       kFileReadOnly|kFileNonBlocking);
+    assert(stdin_dup != NULL);
+
+    StringBuilder sb = KV_INITIAL_VALUE;
+    kv_resize(sb, 64);
+    ptrdiff_t read_size = -1;
+    // Read all input from stdin, unless interrupted (ctrl-c).
+    while (true) {
+      if (got_int) {  // User canceled.
+        return false;
+      }
+      read_size = file_read(stdin_dup, IObuff, 64);
+      if (read_size < 0) {  // Error.
+        return false;
+      }
+      kv_concat_len(sb, IObuff, (size_t)read_size);
+      if (read_size < 64) {  // EOF.
+        break;
+      }
+    }
+    kv_push(sb, NUL);
+    file_free(stdin_dup, false);
 
-  lua_getglobal(lstate, "loadfile");
-  lua_pushstring(lstate, path);
+    lua_getglobal(lstate, "loadstring");
+    lua_pushstring(lstate, sb.items);
+    kv_destroy(sb);
+  }
 
   if (nlua_pcall(lstate, 1, 2)) {
     nlua_error(lstate, _("E5111: Error calling lua: %.*s"));
-- 
cgit 


From 7089f331447bf335696276e969649fb6ee360e07 Mon Sep 17 00:00:00 2001
From: "Justin M. Keyes" <justinkz@gmail.com>
Date: Thu, 5 Jan 2023 09:25:19 +0100
Subject: refactor(lua): move _G.arg init to nlua_init()

---
 src/nvim/lua/executor.c | 12 ++++--------
 1 file changed, 4 insertions(+), 8 deletions(-)

(limited to 'src/nvim/lua')

diff --git a/src/nvim/lua/executor.c b/src/nvim/lua/executor.c
index b7844363c5..c756242817 100644
--- a/src/nvim/lua/executor.c
+++ b/src/nvim/lua/executor.c
@@ -335,9 +335,8 @@ static int nlua_thr_api_nvim__get_runtime(lua_State *lstate)
 /// @see https://github.com/premake/premake-core/blob/1c1304637f4f5e50ba8c57aae8d1d80ec3b7aaf2/src/host/premake.c#L563-L594
 ///
 /// @returns number of args
-int nlua_init_argv(char **argv, int argc, int lua_arg0)
+static int nlua_init_argv(lua_State *const L, char **argv, int argc, int lua_arg0)
 {
-  lua_State *const L = global_lstate;
   lua_newtable(L);  // _G.arg
   int i = 0;
   for (; lua_arg0 >= 0 && i + lua_arg0 < argc; i++) {
@@ -790,10 +789,8 @@ static bool nlua_state_init(lua_State *const lstate) FUNC_ATTR_NONNULL_ALL
   return true;
 }
 
-/// Initialize global lua interpreter
-///
-/// Crashes Nvim if initialization fails.
-void nlua_init(void)
+/// Initializes global Lua interpreter, or exits Nvim on failure.
+void nlua_init(char **argv, int argc, int lua_arg0)
 {
 #ifdef NLUA_TRACK_REFS
   const char *env = os_getenv("NVIM_LUA_NOTRACK");
@@ -814,10 +811,9 @@ void nlua_init(void)
   }
 
   luv_set_thread_cb(nlua_thread_acquire_vm, nlua_common_free_all_mem);
-
   global_lstate = lstate;
-
   main_thread = uv_thread_self();
+  nlua_init_argv(lstate, argv, argc, lua_arg0);
 }
 
 static lua_State *nlua_thread_acquire_vm(void)
-- 
cgit 


From 628b717022815a431ea0b980444d6115c644f8c8 Mon Sep 17 00:00:00 2001
From: "Justin M. Keyes" <justinkz@gmail.com>
Date: Thu, 5 Jan 2023 17:39:03 +0100
Subject: refactor: extract code to open stdin for reading

---
 src/nvim/lua/executor.c | 15 +--------------
 1 file changed, 1 insertion(+), 14 deletions(-)

(limited to 'src/nvim/lua')

diff --git a/src/nvim/lua/executor.c b/src/nvim/lua/executor.c
index c756242817..307b34a55c 100644
--- a/src/nvim/lua/executor.c
+++ b/src/nvim/lua/executor.c
@@ -1724,20 +1724,7 @@ bool nlua_exec_file(const char *path)
     lua_getglobal(lstate, "loadfile");
     lua_pushstring(lstate, path);
   } else {
-    int error;
-    int stdin_dup_fd;
-    if (stdin_fd > 0) {
-      stdin_dup_fd = stdin_fd;
-    } else {
-      stdin_dup_fd = os_dup(STDIN_FILENO);
-#ifdef MSWIN
-      // Replace the original stdin with the console input handle.
-      os_replace_stdin_to_conin();
-#endif
-    }
-    FileDescriptor *const stdin_dup = file_open_fd_new(&error, stdin_dup_fd,
-                                                       kFileReadOnly|kFileNonBlocking);
-    assert(stdin_dup != NULL);
+    FileDescriptor *stdin_dup = file_open_stdin();
 
     StringBuilder sb = KV_INITIAL_VALUE;
     kv_resize(sb, 64);
-- 
cgit 


From 1c6be5e5e67407d56001826999351806ae655fe5 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Sat, 7 Jan 2023 07:50:48 +0800
Subject: fix(coverity/433537): don't call kv_concat_len() when read_size is 0
 (#21664)

fix(coverity): don't call kv_concat_len() when read_size is 0
---
 src/nvim/lua/executor.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'src/nvim/lua')

diff --git a/src/nvim/lua/executor.c b/src/nvim/lua/executor.c
index 307b34a55c..4ac3c78b0a 100644
--- a/src/nvim/lua/executor.c
+++ b/src/nvim/lua/executor.c
@@ -1738,7 +1738,9 @@ bool nlua_exec_file(const char *path)
       if (read_size < 0) {  // Error.
         return false;
       }
-      kv_concat_len(sb, IObuff, (size_t)read_size);
+      if (read_size > 0) {
+        kv_concat_len(sb, IObuff, (size_t)read_size);
+      }
       if (read_size < 64) {  // EOF.
         break;
       }
-- 
cgit 


From e17430c1cd97db5624e27515a4f5da17f9d926d6 Mon Sep 17 00:00:00 2001
From: "Justin M. Keyes" <justinkz@gmail.com>
Date: Sat, 7 Jan 2023 02:12:54 +0100
Subject: feat(lua): store "nvim -l" scriptname in _G.arg[0]

---
 src/nvim/lua/executor.c | 22 ++++++++++++++--------
 1 file changed, 14 insertions(+), 8 deletions(-)

(limited to 'src/nvim/lua')

diff --git a/src/nvim/lua/executor.c b/src/nvim/lua/executor.c
index 4ac3c78b0a..cd022068ce 100644
--- a/src/nvim/lua/executor.c
+++ b/src/nvim/lua/executor.c
@@ -323,13 +323,12 @@ static int nlua_thr_api_nvim__get_runtime(lua_State *lstate)
   return 1;
 }
 
-/// Copies args starting at `lua_arg0` into the Lua `arg` global.
+/// Copies args starting at `lua_arg0` to Lua `_G.arg`, and sets `_G.arg[0]` to the scriptname.
 ///
-/// Example (`lua_arg0` points to "--arg1"):
+/// Example (arg[0] => "foo.lua", arg[1] => "--arg1", …):
 ///     nvim -l foo.lua --arg1 --arg2
 ///
-/// @note Lua CLI sets arguments upto "-e" as _negative_ `_G.arg` indices, but we currently don't
-/// follow that convention.
+/// @note Lua CLI sets args before "-e" as _negative_ `_G.arg` indices, but we currently don't.
 ///
 /// @see https://www.lua.org/pil/1.4.html
 /// @see https://github.com/premake/premake-core/blob/1c1304637f4f5e50ba8c57aae8d1d80ec3b7aaf2/src/host/premake.c#L563-L594
@@ -337,12 +336,19 @@ static int nlua_thr_api_nvim__get_runtime(lua_State *lstate)
 /// @returns number of args
 static int nlua_init_argv(lua_State *const L, char **argv, int argc, int lua_arg0)
 {
-  lua_newtable(L);  // _G.arg
   int i = 0;
-  for (; lua_arg0 >= 0 && i + lua_arg0 < argc; i++) {
-    lua_pushstring(L, argv[i + lua_arg0]);
-    lua_rawseti(L, -2, i + 1);  // _G.arg[i+1] = "arg1"
+  lua_newtable(L);  // _G.arg
+
+  if (lua_arg0 > 0) {
+    lua_pushstring(L, argv[lua_arg0 - 1]);
+    lua_rawseti(L, -2, 0);  // _G.arg[0] = "foo.lua"
+
+    for (; lua_arg0 >= 0 && i + lua_arg0 < argc; i++) {
+      lua_pushstring(L, argv[i + lua_arg0]);
+      lua_rawseti(L, -2, i + 1);  // _G.arg[i+1] = "--foo"
+    }
   }
+
   lua_setglobal(L, "arg");
   return i;
 }
-- 
cgit 


From 50f03773f4b9f4638489ccfd0503dc9e39e5de78 Mon Sep 17 00:00:00 2001
From: dundargoc <33953936+dundargoc@users.noreply.github.com>
Date: Mon, 9 Jan 2023 15:37:34 +0100
Subject: refactor: replace char_u with char 18 (#21237)

refactor: replace char_u with char

Work on https://github.com/neovim/neovim/issues/459
---
 src/nvim/lua/executor.c   | 14 +++++++-------
 src/nvim/lua/treesitter.c |  8 ++++----
 2 files changed, 11 insertions(+), 11 deletions(-)

(limited to 'src/nvim/lua')

diff --git a/src/nvim/lua/executor.c b/src/nvim/lua/executor.c
index cd022068ce..12ddbd094f 100644
--- a/src/nvim/lua/executor.c
+++ b/src/nvim/lua/executor.c
@@ -1052,8 +1052,8 @@ static int nlua_require(lua_State *const lstate)
   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);
+    vim_snprintf(IObuff, IOSIZE, "require('%s')", name);
+    time_msg(IObuff, &start_time);
   }
   time_pop(rel_time);
 
@@ -1342,7 +1342,7 @@ void nlua_typval_eval(const String str, typval_T *const arg, typval_T *const ret
   const size_t lcmd_len = sizeof(EVALHEADER) - 1 + str.size + 1;
   char *lcmd;
   if (lcmd_len < IOSIZE) {
-    lcmd = (char *)IObuff;
+    lcmd = IObuff;
   } else {
     lcmd = xmalloc(lcmd_len);
   }
@@ -1352,7 +1352,7 @@ void nlua_typval_eval(const String str, typval_T *const arg, typval_T *const ret
 #undef EVALHEADER
   nlua_typval_exec(lcmd, lcmd_len, "luaeval()", arg, 1, true, ret_tv);
 
-  if (lcmd != (char *)IObuff) {
+  if (lcmd != IObuff) {
     xfree(lcmd);
   }
 }
@@ -1366,7 +1366,7 @@ void nlua_typval_call(const char *str, size_t len, typval_T *const args, int arg
   const size_t lcmd_len = sizeof(CALLHEADER) - 1 + len + sizeof(CALLSUFFIX) - 1;
   char *lcmd;
   if (lcmd_len < IOSIZE) {
-    lcmd = (char *)IObuff;
+    lcmd = IObuff;
   } else {
     lcmd = xmalloc(lcmd_len);
   }
@@ -1379,7 +1379,7 @@ void nlua_typval_call(const char *str, size_t len, typval_T *const args, int arg
 
   nlua_typval_exec(lcmd, lcmd_len, "v:lua", args, argcount, false, ret_tv);
 
-  if (lcmd != (char *)IObuff) {
+  if (lcmd != IObuff) {
     xfree(lcmd);
   }
 }
@@ -1645,7 +1645,7 @@ void ex_luado(exarg_T *const eap)
                            + (sizeof(DOEND) - 1));
   char *lcmd;
   if (lcmd_len < IOSIZE) {
-    lcmd = (char *)IObuff;
+    lcmd = IObuff;
   } else {
     lcmd = xmalloc(lcmd_len + 1);
   }
diff --git a/src/nvim/lua/treesitter.c b/src/nvim/lua/treesitter.c
index d77e210c6a..fecf746036 100644
--- a/src/nvim/lua/treesitter.c
+++ b/src/nvim/lua/treesitter.c
@@ -182,19 +182,19 @@ int tslua_add_language(lua_State *L)
 
   uv_lib_t lib;
   if (uv_dlopen(path, &lib)) {
-    snprintf((char *)IObuff, IOSIZE, "Failed to load parser: uv_dlopen: %s",
+    snprintf(IObuff, IOSIZE, "Failed to load parser: uv_dlopen: %s",
              uv_dlerror(&lib));
     uv_dlclose(&lib);
-    lua_pushstring(L, (char *)IObuff);
+    lua_pushstring(L, IObuff);
     return lua_error(L);
   }
 
   TSLanguage *(*lang_parser)(void);
   if (uv_dlsym(&lib, symbol_buf, (void **)&lang_parser)) {
-    snprintf((char *)IObuff, IOSIZE, "Failed to load parser: uv_dlsym: %s",
+    snprintf(IObuff, IOSIZE, "Failed to load parser: uv_dlsym: %s",
              uv_dlerror(&lib));
     uv_dlclose(&lib);
-    lua_pushstring(L, (char *)IObuff);
+    lua_pushstring(L, IObuff);
     return lua_error(L);
   }
 
-- 
cgit 


From e89c39d6f016a4140293755250e968e839009617 Mon Sep 17 00:00:00 2001
From: dundargoc <33953936+dundargoc@users.noreply.github.com>
Date: Sat, 14 Jan 2023 08:58:28 +0100
Subject: refactor: replace char_u with char 21 (#21779)

refactor: replace char_u with char

Work on https://github.com/neovim/neovim/issues/459
---
 src/nvim/lua/stdlib.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/nvim/lua')

diff --git a/src/nvim/lua/stdlib.c b/src/nvim/lua/stdlib.c
index 813f86eeee..dac96790d7 100644
--- a/src/nvim/lua/stdlib.c
+++ b/src/nvim/lua/stdlib.c
@@ -176,7 +176,7 @@ int nlua_str_utfindex(lua_State *const lstate) FUNC_ATTR_NONNULL_ALL
   }
 
   size_t codepoints = 0, codeunits = 0;
-  mb_utflen((const char_u *)s1, (size_t)idx, &codepoints, &codeunits);
+  mb_utflen(s1, (size_t)idx, &codepoints, &codeunits);
 
   lua_pushinteger(lstate, (long)codepoints);
   lua_pushinteger(lstate, (long)codeunits);
-- 
cgit 


From 3269902a13df3bccf8705db73488c0a47f495514 Mon Sep 17 00:00:00 2001
From: dundargoc <33953936+dundargoc@users.noreply.github.com>
Date: Sun, 15 Jan 2023 14:16:33 +0100
Subject: refactor: fix IWYU mapping file and use IWYU (#21802)

Also add the EXITFREE definition to main_lib rather than the nvim target, as the header generation needs the EXITFREE flag to work properly.
---
 src/nvim/lua/executor.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/nvim/lua')

diff --git a/src/nvim/lua/executor.c b/src/nvim/lua/executor.c
index 12ddbd094f..f23310304f 100644
--- a/src/nvim/lua/executor.c
+++ b/src/nvim/lua/executor.c
@@ -49,6 +49,7 @@
 #include "nvim/message.h"
 #include "nvim/msgpack_rpc/channel.h"
 #include "nvim/option_defs.h"
+#include "nvim/os/fileio.h"
 #include "nvim/os/os.h"
 #include "nvim/path.h"
 #include "nvim/pos.h"
@@ -56,7 +57,6 @@
 #include "nvim/runtime.h"
 #include "nvim/strings.h"
 #include "nvim/ui.h"
-#include "nvim/ui_compositor.h"
 #include "nvim/undo.h"
 #include "nvim/usercmd.h"
 #include "nvim/version.h"
-- 
cgit 


From 0344bfad0fc87d2e256ea2b80de7abd069ba1dd2 Mon Sep 17 00:00:00 2001
From: dundargoc <33953936+dundargoc@users.noreply.github.com>
Date: Tue, 17 Jan 2023 14:17:40 +0100
Subject: refactor: replace char_u with char 22 (#21786)

Work on https://github.com/neovim/neovim/issues/459
---
 src/nvim/lua/spell.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/nvim/lua')

diff --git a/src/nvim/lua/spell.c b/src/nvim/lua/spell.c
index 0a566b2f86..d510d25e90 100644
--- a/src/nvim/lua/spell.c
+++ b/src/nvim/lua/spell.c
@@ -61,7 +61,7 @@ int nlua_spell_check(lua_State *lstate)
 
   while (*str != NUL) {
     attr = HLF_COUNT;
-    len = spell_check(curwin, (char_u *)str, &attr, &capcol, false);
+    len = spell_check(curwin, (char *)str, &attr, &capcol, false);
     assert(len <= INT_MAX);
 
     if (attr != HLF_COUNT) {
-- 
cgit 


From 8a4285d5637c146a0ae606918a8e77063c6a5f0d Mon Sep 17 00:00:00 2001
From: dundargoc <33953936+dundargoc@users.noreply.github.com>
Date: Wed, 18 Jan 2023 14:17:11 +0100
Subject: refactor: replace char_u with char 24 (#21823)

refactor: replace char_u with char

Work on https://github.com/neovim/neovim/issues/459
---
 src/nvim/lua/converter.c |  2 +-
 src/nvim/lua/executor.c  |  2 +-
 src/nvim/lua/stdlib.c    | 27 +++++++++++++--------------
 3 files changed, 15 insertions(+), 16 deletions(-)

(limited to 'src/nvim/lua')

diff --git a/src/nvim/lua/converter.c b/src/nvim/lua/converter.c
index 3c129fe7ce..6160b84485 100644
--- a/src/nvim/lua/converter.c
+++ b/src/nvim/lua/converter.c
@@ -391,7 +391,7 @@ nlua_pop_typval_table_processing_end:
     case LUA_TFUNCTION: {
       LuaRef func = nlua_ref_global(lstate, -1);
 
-      char *name = (char *)register_luafunc(func);
+      char *name = register_luafunc(func);
 
       cur.tv->v_type = VAR_FUNC;
       cur.tv->vval.v_string = xstrdup(name);
diff --git a/src/nvim/lua/executor.c b/src/nvim/lua/executor.c
index f23310304f..7006c1dc4e 100644
--- a/src/nvim/lua/executor.c
+++ b/src/nvim/lua/executor.c
@@ -1950,7 +1950,7 @@ char_u *nlua_register_table_as_callable(const typval_T *const arg)
 
   LuaRef func = nlua_ref_global(lstate, -1);
 
-  char_u *name = register_luafunc(func);
+  char_u *name = (char_u *)register_luafunc(func);
 
   lua_pop(lstate, 1);  // []
   assert(top == lua_gettop(lstate));
diff --git a/src/nvim/lua/stdlib.c b/src/nvim/lua/stdlib.c
index dac96790d7..8b74418753 100644
--- a/src/nvim/lua/stdlib.c
+++ b/src/nvim/lua/stdlib.c
@@ -40,17 +40,17 @@
 # include "lua/stdlib.c.generated.h"
 #endif
 
-static int regex_match(lua_State *lstate, regprog_T **prog, char_u *str)
+static int regex_match(lua_State *lstate, regprog_T **prog, char *str)
 {
   regmatch_T rm;
   rm.regprog = *prog;
   rm.rm_ic = false;
-  bool match = vim_regexec(&rm, (char *)str, 0);
+  bool match = vim_regexec(&rm, str, 0);
   *prog = rm.regprog;
 
   if (match) {
-    lua_pushinteger(lstate, (lua_Integer)(rm.startp[0] - (char *)str));
-    lua_pushinteger(lstate, (lua_Integer)(rm.endp[0] - (char *)str));
+    lua_pushinteger(lstate, (lua_Integer)(rm.startp[0] - str));
+    lua_pushinteger(lstate, (lua_Integer)(rm.endp[0] - str));
     return 2;
   }
   return 0;
@@ -60,7 +60,7 @@ static int regex_match_str(lua_State *lstate)
 {
   regprog_T **prog = regex_check(lstate);
   const char *str = luaL_checkstring(lstate, 2);
-  int nret = regex_match(lstate, prog, (char_u *)str);
+  int nret = regex_match(lstate, prog, (char *)str);
 
   if (!*prog) {
     return luaL_error(lstate, "regex: internal error");
@@ -116,7 +116,7 @@ static int regex_match_line(lua_State *lstate)
     line[end] = NUL;
   }
 
-  int nret = regex_match(lstate, prog, (char_u *)line + start);
+  int nret = regex_match(lstate, prog, line + start);
 
   if (end >= 0) {
     line[end] = save;
@@ -198,7 +198,7 @@ static int nlua_str_utf_pos(lua_State *const lstate) FUNC_ATTR_NONNULL_ALL
   size_t idx = 1;
   size_t clen;
   for (size_t i = 0; i < s1_len && s1[i] != NUL; i += clen) {
-    clen = (size_t)utf_ptr2len_len((const char_u *)(s1) + i, (int)(s1_len - i));
+    clen = (size_t)utf_ptr2len_len(s1 + i, (int)(s1_len - i));
     lua_pushinteger(lstate, (long)i + 1);
     lua_rawseti(lstate, -2, (int)idx);
     idx++;
@@ -266,8 +266,7 @@ int nlua_str_byteindex(lua_State *const lstate) FUNC_ATTR_NONNULL_ALL
     use_utf16 = lua_toboolean(lstate, 3);
   }
 
-  ssize_t byteidx = mb_utf_index_to_bytes((const char_u *)s1, s1_len,
-                                          (size_t)idx, use_utf16);
+  ssize_t byteidx = mb_utf_index_to_bytes(s1, s1_len, (size_t)idx, use_utf16);
   if (byteidx == -1) {
     return luaL_error(lstate, "index out of range");
   }
@@ -503,14 +502,14 @@ static int nlua_iconv(lua_State *lstate)
   size_t str_len = 0;
   const char *str = lua_tolstring(lstate, 1, &str_len);
 
-  char_u *from = (char_u *)enc_canonize(enc_skip((char *)lua_tolstring(lstate, 2, NULL)));
-  char_u *to   = (char_u *)enc_canonize(enc_skip((char *)lua_tolstring(lstate, 3, NULL)));
+  char *from = enc_canonize(enc_skip((char *)lua_tolstring(lstate, 2, NULL)));
+  char *to   = enc_canonize(enc_skip((char *)lua_tolstring(lstate, 3, NULL)));
 
   vimconv_T vimconv;
   vimconv.vc_type = CONV_NONE;
-  convert_setup_ext(&vimconv, (char *)from, false, (char *)to, false);
+  convert_setup_ext(&vimconv, from, false, to, false);
 
-  char_u *ret = (char_u *)string_convert(&vimconv, (char *)str, &str_len);
+  char *ret = string_convert(&vimconv, (char *)str, &str_len);
 
   convert_setup(&vimconv, NULL, NULL);
 
@@ -520,7 +519,7 @@ static int nlua_iconv(lua_State *lstate)
   if (ret == NULL) {
     lua_pushnil(lstate);
   } else {
-    lua_pushlstring(lstate, (char *)ret, str_len);
+    lua_pushlstring(lstate, ret, str_len);
     xfree(ret);
   }
 
-- 
cgit 


From 4c531714ff24d82bf1a85decf0e0c63c5785e686 Mon Sep 17 00:00:00 2001
From: dundargoc <33953936+dundargoc@users.noreply.github.com>
Date: Thu, 19 Jan 2023 15:25:56 +0100
Subject: refactor: replace char_u with char 25 (#21838)

refactor: replace char_u with char

Work on https://github.com/neovim/neovim/issues/459
---
 src/nvim/lua/executor.c | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

(limited to 'src/nvim/lua')

diff --git a/src/nvim/lua/executor.c b/src/nvim/lua/executor.c
index 7006c1dc4e..5ffd90fddd 100644
--- a/src/nvim/lua/executor.c
+++ b/src/nvim/lua/executor.c
@@ -1440,11 +1440,11 @@ int nlua_source_using_linegetter(LineGetter fgetline, void *cookie, char *name)
   estack_push(ETYPE_SCRIPT, name, 0);
 
   garray_T ga;
-  char_u *line = NULL;
+  char *line = NULL;
 
-  ga_init(&ga, (int)sizeof(char_u *), 10);
-  while ((line = (char_u *)fgetline(0, cookie, 0, false)) != NULL) {
-    GA_APPEND(char_u *, &ga, line);
+  ga_init(&ga, (int)sizeof(char *), 10);
+  while ((line = fgetline(0, cookie, 0, false)) != NULL) {
+    GA_APPEND(char *, &ga, line);
   }
   char *code = ga_concat_strings_sep(&ga, "\n");
   size_t len = strlen(code);
@@ -1877,7 +1877,7 @@ int nlua_expand_pat(expand_T *xp, char *pat, int *num_results, char ***results)
       goto cleanup_array;
     }
 
-    GA_APPEND(char_u *, &result_array, (char_u *)string_to_cstr(v.data.string));
+    GA_APPEND(char *, &result_array, string_to_cstr(v.data.string));
   }
 
   xp->xp_pattern += prefix_len;
@@ -1914,7 +1914,7 @@ bool nlua_is_table_from_lua(const typval_T *const arg)
   }
 }
 
-char_u *nlua_register_table_as_callable(const typval_T *const arg)
+char *nlua_register_table_as_callable(const typval_T *const arg)
 {
   LuaRef table_ref = LUA_NOREF;
   if (arg->v_type == VAR_DICT) {
@@ -1950,7 +1950,7 @@ char_u *nlua_register_table_as_callable(const typval_T *const arg)
 
   LuaRef func = nlua_ref_global(lstate, -1);
 
-  char_u *name = (char_u *)register_luafunc(func);
+  char *name = register_luafunc(func);
 
   lua_pop(lstate, 1);  // []
   assert(top == lua_gettop(lstate));
@@ -1960,8 +1960,8 @@ char_u *nlua_register_table_as_callable(const typval_T *const arg)
 
 void nlua_execute_on_key(int c)
 {
-  char_u buf[NUMBUFLEN];
-  size_t buf_len = special_to_buf(c, mod_mask, false, buf);
+  char buf[NUMBUFLEN];
+  size_t buf_len = special_to_buf(c, mod_mask, false, (char_u *)buf);
 
   lua_State *const lstate = global_lstate;
 
@@ -1977,7 +1977,7 @@ void nlua_execute_on_key(int c)
   luaL_checktype(lstate, -1, LUA_TFUNCTION);
 
   // [ vim, vim._on_key, buf ]
-  lua_pushlstring(lstate, (const char *)buf, buf_len);
+  lua_pushlstring(lstate, buf, buf_len);
 
   int save_got_int = got_int;
   got_int = false;  // avoid interrupts when the key typed is Ctrl-C
-- 
cgit 


From 151b9fc52e3cd69b386eb2dc4e5a0d179667190b Mon Sep 17 00:00:00 2001
From: Matthieu Coudron <teto@users.noreply.github.com>
Date: Sun, 22 Jan 2023 16:51:17 +0100
Subject: feat(treesitter): show filetype associated with parser (#17633)

to ease debug. At one point I had an empty filetype and the current message was not helpful enough
---
 src/nvim/lua/treesitter.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'src/nvim/lua')

diff --git a/src/nvim/lua/treesitter.c b/src/nvim/lua/treesitter.c
index fecf746036..56f4daed1a 100644
--- a/src/nvim/lua/treesitter.c
+++ b/src/nvim/lua/treesitter.c
@@ -182,8 +182,8 @@ int tslua_add_language(lua_State *L)
 
   uv_lib_t lib;
   if (uv_dlopen(path, &lib)) {
-    snprintf(IObuff, IOSIZE, "Failed to load parser: uv_dlopen: %s",
-             uv_dlerror(&lib));
+    snprintf(IObuff, IOSIZE, "Failed to load parser for language '%s': uv_dlopen: %s",
+             lang_name, uv_dlerror(&lib));
     uv_dlclose(&lib);
     lua_pushstring(L, IObuff);
     return lua_error(L);
-- 
cgit 


From f08051c2e61f63b2088a42d641393253b8ca1ca1 Mon Sep 17 00:00:00 2001
From: Lewis Russell <lewis6991@gmail.com>
Date: Mon, 23 Jan 2023 16:33:45 +0000
Subject: feat!: make iconv a non-optional dep

---
 src/nvim/lua/stdlib.c | 6 ------
 1 file changed, 6 deletions(-)

(limited to 'src/nvim/lua')

diff --git a/src/nvim/lua/stdlib.c b/src/nvim/lua/stdlib.c
index 8b74418753..6ebca6d97e 100644
--- a/src/nvim/lua/stdlib.c
+++ b/src/nvim/lua/stdlib.c
@@ -482,8 +482,6 @@ static int nlua_stricmp(lua_State *const lstate) FUNC_ATTR_NONNULL_ALL
   return 1;
 }
 
-#if defined(HAVE_ICONV)
-
 /// Convert string from one encoding to another
 static int nlua_iconv(lua_State *lstate)
 {
@@ -526,8 +524,6 @@ static int nlua_iconv(lua_State *lstate)
   return 1;
 }
 
-#endif
-
 void nlua_state_add_stdlib(lua_State *const lstate, bool is_thread)
 {
   if (!is_thread) {
@@ -574,12 +570,10 @@ void nlua_state_add_stdlib(lua_State *const lstate, bool is_thread)
     luaopen_spell(lstate);
     lua_setfield(lstate, -2, "spell");
 
-#if defined(HAVE_ICONV)
     // vim.iconv
     // depends on p_ambw, p_emoji
     lua_pushcfunction(lstate, &nlua_iconv);
     lua_setfield(lstate, -2, "iconv");
-#endif
   }
 
   // vim.mpack
-- 
cgit