*: Fix errors from new linter checks

24 files changed, 610 insertions, 612 deletions

diff --git a/src/nvim/api/private/handle.c b/src/nvim/api/private/handle.c
index abbda95073..69df7294ad 100644
--- a/src/nvim/api/private/handle.c
+++ b/src/nvim/api/private/handle.c
@@ -7,24 +7,24 @@
 
 #define HANDLE_INIT(name) name##_handles = pmap_new(uint64_t)()
 
-#define HANDLE_IMPL(type, name)                                               \
-  static PMap(uint64_t) *name##_handles = NULL;                               \
-                                                                              \
-  type *handle_get_##name(uint64_t handle)                                    \
-  {                                                                           \
-    return pmap_get(uint64_t)(name##_handles, handle);                        \
-  }                                                                           \
-                                                                              \
-  void handle_register_##name(type *name)                                     \
-  {                                                                           \
-    assert(!name->handle);                                                    \
-    name->handle = next_handle++;                                             \
-    pmap_put(uint64_t)(name##_handles, name->handle, name);                   \
-  }                                                                           \
-                                                                              \
-  void handle_unregister_##name(type *name)                                   \
-  {                                                                           \
-    pmap_del(uint64_t)(name##_handles, name->handle);                         \
+#define HANDLE_IMPL(type, name) \
+  static PMap(uint64_t) *name##_handles = NULL; \
+  \
+  type *handle_get_##name(uint64_t handle) \
+  { \
+    return pmap_get(uint64_t)(name##_handles, handle); \
+  } \
+  \
+  void handle_register_##name(type *name) \
+  { \
+    assert(!name->handle); \
+    name->handle = next_handle++; \
+    pmap_put(uint64_t)(name##_handles, name->handle, name); \
+  } \
+  \
+  void handle_unregister_##name(type *name) \
+  { \
+    pmap_del(uint64_t)(name##_handles, name->handle); \
   }
 
 static uint64_t next_handle = 1;
diff --git a/src/nvim/api/private/handle.h b/src/nvim/api/private/handle.h
index 1a196f6797..804e266dc3 100644
--- a/src/nvim/api/private/handle.h
+++ b/src/nvim/api/private/handle.h
@@ -4,9 +4,9 @@
 #include "nvim/vim.h"
 #include "nvim/buffer_defs.h"
 
-#define HANDLE_DECLS(type, name)                                              \
-  type *handle_get_##name(uint64_t handle);                                   \
-  void handle_register_##name(type *name);                                    \
+#define HANDLE_DECLS(type, name) \
+  type *handle_get_##name(uint64_t handle); \
+  void handle_register_##name(type *name); \
   void handle_unregister_##name(type *name);
 
 HANDLE_DECLS(buf_T, buffer)
diff --git a/src/nvim/api/private/helpers.h b/src/nvim/api/private/helpers.h
index 7ed726c7ce..861becd0b3 100644
--- a/src/nvim/api/private/helpers.h
+++ b/src/nvim/api/private/helpers.h
@@ -8,63 +8,63 @@
 #include "nvim/memory.h"
 #include "nvim/lib/kvec.h"
 
-#define api_set_error(err, errtype, ...)             \
-  do {                                               \
-    snprintf((err)->msg,                             \
-             sizeof((err)->msg),                     \
-             __VA_ARGS__);                           \
-    (err)->set = true;                               \
-    (err)->type = kErrorType##errtype;               \
+#define api_set_error(err, errtype, ...) \
+  do { \
+    snprintf((err)->msg, \
+             sizeof((err)->msg), \
+             __VA_ARGS__); \
+    (err)->set = true; \
+    (err)->type = kErrorType##errtype; \
   } while (0)
 
 #define OBJECT_OBJ(o) o
 
-#define BOOLEAN_OBJ(b) ((Object) {                                            \
-  .type = kObjectTypeBoolean,                                                 \
-  .data.boolean = b                                                           \
+#define BOOLEAN_OBJ(b) ((Object) { \
+  .type = kObjectTypeBoolean, \
+  .data.boolean = b \
   })
 
-#define INTEGER_OBJ(i) ((Object) {                                            \
-  .type = kObjectTypeInteger,                                                 \
-  .data.integer = i                                                           \
+#define INTEGER_OBJ(i) ((Object) { \
+  .type = kObjectTypeInteger, \
+  .data.integer = i \
   })
 
-#define STRING_OBJ(s) ((Object) {                                             \
-  .type = kObjectTypeString,                                                  \
-  .data.string = s                                                            \
+#define STRING_OBJ(s) ((Object) { \
+  .type = kObjectTypeString, \
+  .data.string = s \
   })
 
-#define BUFFER_OBJ(s) ((Object) {                                             \
-  .type = kObjectTypeBuffer,                                                  \
-  .data.buffer = s                                                            \
+#define BUFFER_OBJ(s) ((Object) { \
+  .type = kObjectTypeBuffer, \
+  .data.buffer = s \
   })
 
-#define WINDOW_OBJ(s) ((Object) {                                             \
-  .type = kObjectTypeWindow,                                                  \
-  .data.window = s                                                            \
+#define WINDOW_OBJ(s) ((Object) { \
+  .type = kObjectTypeWindow, \
+  .data.window = s \
   })
 
-#define TABPAGE_OBJ(s) ((Object) {                                            \
-  .type = kObjectTypeTabpage,                                                 \
-  .data.tabpage = s                                                           \
+#define TABPAGE_OBJ(s) ((Object) { \
+  .type = kObjectTypeTabpage, \
+  .data.tabpage = s \
   })
 
-#define ARRAY_OBJ(a) ((Object) {                                              \
-  .type = kObjectTypeArray,                                                   \
-  .data.array = a                                                             \
+#define ARRAY_OBJ(a) ((Object) { \
+  .type = kObjectTypeArray, \
+  .data.array = a \
   })
 
-#define DICTIONARY_OBJ(d) ((Object) {                                         \
-  .type = kObjectTypeDictionary,                                              \
-  .data.dictionary = d                                                        \
+#define DICTIONARY_OBJ(d) ((Object) { \
+  .type = kObjectTypeDictionary, \
+  .data.dictionary = d \
   })
 
 #define NIL ((Object) {.type = kObjectTypeNil})
 
-#define PUT(dict, k, v)                                                       \
+#define PUT(dict, k, v) \
   kv_push(dict, ((KeyValuePair) { .key = cstr_to_string(k), .value = v }))
 
-#define ADD(array, item)                                                      \
+#define ADD(array, item) \
   kv_push(array, item)
 
 #define STATIC_CSTR_AS_STRING(s) ((String) {.data = s, .size = sizeof(s) - 1})
diff --git a/src/nvim/api/vim.c b/src/nvim/api/vim.c
index 43d58a539a..ac7cc65ee4 100644
--- a/src/nvim/api/vim.c
+++ b/src/nvim/api/vim.c
@@ -647,14 +647,14 @@ static void write_msg(String message, bool to_err)
   static size_t out_pos = 0, err_pos = 0;
   static char out_line_buf[LINE_BUFFER_SIZE], err_line_buf[LINE_BUFFER_SIZE];
 
-#define PUSH_CHAR(i, pos, line_buf, msg)                                      \
-  if (message.data[i] == NL || pos == LINE_BUFFER_SIZE - 1) {                 \
-    line_buf[pos] = NUL;                                                      \
-    msg((uint8_t *)line_buf);                                                 \
-    pos = 0;                                                                  \
-    continue;                                                                 \
-  }                                                                           \
-                                                                              \
+#define PUSH_CHAR(i, pos, line_buf, msg) \
+  if (message.data[i] == NL || pos == LINE_BUFFER_SIZE - 1) { \
+    line_buf[pos] = NUL; \
+    msg((uint8_t *)line_buf); \
+    pos = 0; \
+    continue; \
+  } \
+  \
   line_buf[pos++] = message.data[i];
 
   ++no_wait_return;
diff --git a/src/nvim/buffer.h b/src/nvim/buffer.h
index d51a2f7dae..36cbec7e60 100644
--- a/src/nvim/buffer.h
+++ b/src/nvim/buffer.h
@@ -76,14 +76,14 @@ static inline void restore_win_for_buf(win_T *save_curwin,
   }
 }
 
-#define WITH_BUFFER(b, code)                                              \
-  do {                                                                    \
-    buf_T *save_curbuf = NULL;                                            \
-    win_T *save_curwin = NULL;                                            \
-    tabpage_T *save_curtab = NULL;                                        \
-    switch_to_win_for_buf(b, &save_curwin, &save_curtab, &save_curbuf);   \
-    code;                                                                 \
-    restore_win_for_buf(save_curwin, save_curtab, save_curbuf);           \
+#define WITH_BUFFER(b, code) \
+  do { \
+    buf_T *save_curbuf = NULL; \
+    win_T *save_curwin = NULL; \
+    tabpage_T *save_curtab = NULL; \
+    switch_to_win_for_buf(b, &save_curwin, &save_curtab, &save_curbuf); \
+    code; \
+    restore_win_for_buf(save_curwin, save_curtab, save_curbuf); \
   } while (0)
 
 
diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index 92d9dc8ecf..5fa6c0c209 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -22160,13 +22160,13 @@ typval_T eval_call_provider(char *provider, char *method, list_T *arguments)
 bool eval_has_provider(char *name)
 {
 
-#define check_provider(name)                                              \
-  if (has_##name == -1) {                                                 \
-    has_##name = !!find_func((uint8_t *)"provider#" #name "#Call");       \
-    if (!has_##name) {                                                    \
-      script_autoload((uint8_t *)"provider#" #name "#Call", false);       \
-      has_##name = !!find_func((uint8_t *)"provider#" #name "#Call");     \
-    }                                                                     \
+#define check_provider(name) \
+  if (has_##name == -1) { \
+    has_##name = !!find_func((uint8_t *)"provider#" #name "#Call"); \
+    if (!has_##name) { \
+      script_autoload((uint8_t *)"provider#" #name "#Call", false); \
+      has_##name = !!find_func((uint8_t *)"provider#" #name "#Call"); \
+    } \
   }
 
   static int has_clipboard = -1, has_python = -1, has_python3 = -1;
diff --git a/src/nvim/event/defs.h b/src/nvim/event/defs.h
index b802866a3d..e5335d9f25 100644
--- a/src/nvim/event/defs.h
+++ b/src/nvim/event/defs.h
@@ -14,19 +14,19 @@ typedef struct message {
 } Event;
 typedef void(*event_scheduler)(Event event, void *data);
 
-#define VA_EVENT_INIT(event, p, h, a)                   \
-  do {                                                  \
-    assert(a <= EVENT_HANDLER_MAX_ARGC);                \
-    (event)->priority = p;                              \
-    (event)->handler = h;                               \
-    if (a) {                                            \
-      va_list args;                                     \
-      va_start(args, a);                                \
-      for (int i = 0; i < a; i++) {                     \
-        (event)->argv[i] = va_arg(args, void *);        \
-      }                                                 \
-      va_end(args);                                     \
-    }                                                   \
+#define VA_EVENT_INIT(event, p, h, a) \
+  do { \
+    assert(a <= EVENT_HANDLER_MAX_ARGC); \
+    (event)->priority = p; \
+    (event)->handler = h; \
+    if (a) { \
+      va_list args; \
+      va_start(args, a); \
+      for (int i = 0; i < a; i++) { \
+        (event)->argv[i] = va_arg(args, void *); \
+      } \
+      va_end(args); \
+    } \
   } while (0)
 
 static inline Event event_create(int priority, argv_callback cb, int argc, ...)
diff --git a/src/nvim/event/loop.h b/src/nvim/event/loop.h
index 0c1fcb5ed9..c37916ae20 100644
--- a/src/nvim/event/loop.h
+++ b/src/nvim/event/loop.h
@@ -26,43 +26,43 @@ typedef struct loop {
   int recursive;
 } Loop;
 
-#define CREATE_EVENT(queue, handler, argc, ...)                  \
-  do {                                                           \
-    if (queue) {                                                 \
-      queue_put((queue), (handler), argc, __VA_ARGS__);          \
-    } else {                                                     \
-      void *argv[argc] = {__VA_ARGS__};                          \
-      (handler)(argv);                                           \
-    }                                                            \
+#define CREATE_EVENT(queue, handler, argc, ...) \
+  do { \
+    if (queue) { \
+      queue_put((queue), (handler), argc, __VA_ARGS__); \
+    } else { \
+      void *argv[argc] = {__VA_ARGS__}; \
+      (handler)(argv); \
+    } \
   } while (0)
 
 // Poll for events until a condition or timeout
-#define LOOP_PROCESS_EVENTS_UNTIL(loop, queue, timeout, condition)           \
-  do {                                                                       \
-    int remaining = timeout;                                                 \
-    uint64_t before = (remaining > 0) ? os_hrtime() : 0;                     \
-    while (!(condition)) {                                                   \
-      LOOP_PROCESS_EVENTS(loop, queue, remaining);                           \
-      if (remaining == 0) {                                                  \
-        break;                                                               \
-      } else if (remaining > 0) {                                            \
-        uint64_t now = os_hrtime();                                          \
-        remaining -= (int) ((now - before) / 1000000);                       \
-        before = now;                                                        \
-        if (remaining <= 0) {                                                \
-          break;                                                             \
-        }                                                                    \
-      }                                                                      \
-    }                                                                        \
+#define LOOP_PROCESS_EVENTS_UNTIL(loop, queue, timeout, condition) \
+  do { \
+    int remaining = timeout; \
+    uint64_t before = (remaining > 0) ? os_hrtime() : 0; \
+    while (!(condition)) { \
+      LOOP_PROCESS_EVENTS(loop, queue, remaining); \
+      if (remaining == 0) { \
+        break; \
+      } else if (remaining > 0) { \
+        uint64_t now = os_hrtime(); \
+        remaining -= (int) ((now - before) / 1000000); \
+        before = now; \
+        if (remaining <= 0) { \
+          break; \
+        } \
+      } \
+    } \
   } while (0)
 
-#define LOOP_PROCESS_EVENTS(loop, queue, timeout)                            \
-  do {                                                                       \
-    if (queue && !queue_empty(queue)) {                                      \
-      queue_process_events(queue);                                           \
-    } else {                                                                 \
-      loop_poll_events(loop, timeout);                                       \
-    }                                                                        \
+#define LOOP_PROCESS_EVENTS(loop, queue, timeout) \
+  do { \
+    if (queue && !queue_empty(queue)) { \
+      queue_process_events(queue); \
+    } else { \
+      loop_poll_events(loop, timeout); \
+    } \
   } while (0)
 
 
diff --git a/src/nvim/event/process.c b/src/nvim/event/process.c
index 0a4cbe724e..1fffdbf957 100644
--- a/src/nvim/event/process.c
+++ b/src/nvim/event/process.c
@@ -22,11 +22,11 @@
 #define TERM_TIMEOUT 1000000000
 #define KILL_TIMEOUT (TERM_TIMEOUT * 2)
 
-#define CLOSE_PROC_STREAM(proc, stream)                             \
-  do {                                                              \
-    if (proc->stream && !proc->stream->closed) {                    \
-      stream_close(proc->stream, NULL);                             \
-    }                                                               \
+#define CLOSE_PROC_STREAM(proc, stream) \
+  do { \
+    if (proc->stream && !proc->stream->closed) { \
+      stream_close(proc->stream, NULL); \
+    } \
   } while (0)
 
 static bool process_is_tearing_down = false;
diff --git a/src/nvim/garray.h b/src/nvim/garray.h
index 642eaf54f0..5d7806bbfa 100644
--- a/src/nvim/garray.h
+++ b/src/nvim/garray.h
@@ -21,10 +21,10 @@ typedef struct growarray {
 
 #define GA_EMPTY(ga_ptr) ((ga_ptr)->ga_len <= 0)
 
-#define GA_APPEND(item_type, gap, item)                                    \
-  do {                                                                     \
-    ga_grow(gap, 1);                                                       \
-    ((item_type *)(gap)->ga_data)[(gap)->ga_len++] = (item);               \
+#define GA_APPEND(item_type, gap, item) \
+  do { \
+    ga_grow(gap, 1); \
+    ((item_type *)(gap)->ga_data)[(gap)->ga_len++] = (item); \
   } while (0)
 
 #define GA_APPEND_VIA_PTR(item_type, gap) \
@@ -49,16 +49,16 @@ static inline void *ga_append_via_ptr(garray_T *gap, size_t item_size)
 /// @param gap the garray to be freed
 /// @param item_type type of the item in the garray
 /// @param free_item_fn free function that takes (*item_type) as parameter
-#define GA_DEEP_CLEAR(gap, item_type, free_item_fn)             \
-  do {                                                          \
-    garray_T *_gap = (gap);                                     \
-    if (_gap->ga_data != NULL) {                                \
-      for (int i = 0; i < _gap->ga_len; i++) {                  \
-        item_type *_item = &(((item_type *)_gap->ga_data)[i]);  \
-        free_item_fn(_item);                                    \
-      }                                                         \
-    }                                                           \
-    ga_clear(_gap);                                             \
+#define GA_DEEP_CLEAR(gap, item_type, free_item_fn) \
+  do { \
+    garray_T *_gap = (gap); \
+    if (_gap->ga_data != NULL) { \
+      for (int i = 0; i < _gap->ga_len; i++) { \
+        item_type *_item = &(((item_type *)_gap->ga_data)[i]); \
+        free_item_fn(_item); \
+      } \
+    } \
+    ga_clear(_gap); \
   } while (false)
 
 #define FREE_PTR_PTR(ptr) xfree(*(ptr))
diff --git a/src/nvim/lib/klist.h b/src/nvim/lib/klist.h
index 1280a927e8..ae9d56f19f 100644
--- a/src/nvim/lib/klist.h
+++ b/src/nvim/lib/klist.h
@@ -33,35 +33,35 @@
 #include "nvim/func_attr.h"
 
 
-#define KMEMPOOL_INIT(name, kmptype_t, kmpfree_f)                       \
-    typedef struct {                                                    \
-        size_t cnt, n, max;                                             \
-        kmptype_t **buf;                                                \
-    } kmp_##name##_t;                                                   \
-    static inline kmp_##name##_t *kmp_init_##name(void) {               \
-        return xcalloc(1, sizeof(kmp_##name##_t));                      \
-    }                                                                   \
-    static inline void kmp_destroy_##name(kmp_##name##_t *mp)           \
-        REAL_FATTR_UNUSED;                                              \
-    static inline void kmp_destroy_##name(kmp_##name##_t *mp) {         \
-        size_t k;                                                       \
-        for (k = 0; k < mp->n; ++k) {                                   \
-            kmpfree_f(mp->buf[k]); xfree(mp->buf[k]);                   \
-        }                                                               \
-        xfree(mp->buf); xfree(mp);                                      \
-    }                                                                   \
-    static inline kmptype_t *kmp_alloc_##name(kmp_##name##_t *mp) {     \
-        ++mp->cnt;                                                      \
-        if (mp->n == 0) return xcalloc(1, sizeof(kmptype_t));           \
-        return mp->buf[--mp->n];                                        \
-    }                                                                   \
+#define KMEMPOOL_INIT(name, kmptype_t, kmpfree_f) \
+    typedef struct { \
+        size_t cnt, n, max; \
+        kmptype_t **buf; \
+    } kmp_##name##_t; \
+    static inline kmp_##name##_t *kmp_init_##name(void) { \
+        return xcalloc(1, sizeof(kmp_##name##_t)); \
+    } \
+    static inline void kmp_destroy_##name(kmp_##name##_t *mp) \
+        REAL_FATTR_UNUSED; \
+    static inline void kmp_destroy_##name(kmp_##name##_t *mp) { \
+        size_t k; \
+        for (k = 0; k < mp->n; ++k) { \
+            kmpfree_f(mp->buf[k]); xfree(mp->buf[k]); \
+        } \
+        xfree(mp->buf); xfree(mp); \
+    } \
+    static inline kmptype_t *kmp_alloc_##name(kmp_##name##_t *mp) { \
+        ++mp->cnt; \
+        if (mp->n == 0) return xcalloc(1, sizeof(kmptype_t)); \
+        return mp->buf[--mp->n]; \
+    } \
     static inline void kmp_free_##name(kmp_##name##_t *mp, kmptype_t *p) { \
-        --mp->cnt;                                                      \
-        if (mp->n == mp->max) {                                         \
-            mp->max = mp->max? mp->max<<1 : 16;                         \
+        --mp->cnt; \
+        if (mp->n == mp->max) { \
+            mp->max = mp->max? mp->max<<1 : 16; \
             mp->buf = xrealloc(mp->buf, sizeof(kmptype_t *) * mp->max); \
-        }                                                               \
-        mp->buf[mp->n++] = p;                                           \
+        } \
+        mp->buf[mp->n++] = p; \
     }
 
 #define kmempool_t(name) kmp_##name##_t
@@ -70,53 +70,53 @@
 #define kmp_alloc(name, mp) kmp_alloc_##name(mp)
 #define kmp_free(name, mp, p) kmp_free_##name(mp, p)
 
-#define KLIST_INIT(name, kltype_t, kmpfree_t)                           \
-    struct __kl1_##name {                                               \
-        kltype_t data;                                                  \
-        struct __kl1_##name *next;                                      \
-    };                                                                  \
-    typedef struct __kl1_##name kl1_##name;                             \
-    KMEMPOOL_INIT(name, kl1_##name, kmpfree_t)                          \
-    typedef struct {                                                    \
-        kl1_##name *head, *tail;                                        \
-        kmp_##name##_t *mp;                                             \
-        size_t size;                                                    \
-    } kl_##name##_t;                                                    \
-    static inline kl_##name##_t *kl_init_##name(void) {                 \
-        kl_##name##_t *kl = xcalloc(1, sizeof(kl_##name##_t));          \
-        kl->mp = kmp_init(name);                                        \
-        kl->head = kl->tail = kmp_alloc(name, kl->mp);                  \
-        kl->head->next = 0;                                             \
-        return kl;                                                      \
-    }                                                                   \
-    static inline void kl_destroy_##name(kl_##name##_t *kl)             \
-        REAL_FATTR_UNUSED;                                              \
-    static inline void kl_destroy_##name(kl_##name##_t *kl) {           \
-        kl1_##name *p;                                                  \
-        for (p = kl->head; p != kl->tail; p = p->next)                  \
-            kmp_free(name, kl->mp, p);                                  \
-        kmp_free(name, kl->mp, p);                                      \
-        kmp_destroy(name, kl->mp);                                      \
-        xfree(kl);                                                      \
-    }                                                                   \
-    static inline void kl_push_##name(kl_##name##_t *kl, kltype_t d) {  \
-        kl1_##name *q, *p = kmp_alloc(name, kl->mp);                    \
-        q = kl->tail; p->next = 0; kl->tail->next = p; kl->tail = p;    \
-        ++kl->size;                                                     \
-        q->data = d;                                                    \
-    }                                                                   \
-    static inline kltype_t kl_shift_at_##name(kl_##name##_t *kl,        \
-                                              kl1_##name **n) {         \
-        assert((*n)->next);                                             \
-        kl1_##name *p;                                                  \
-        --kl->size;                                                     \
-        p = *n;                                                         \
-        *n = (*n)->next;                                                \
-        if (p == kl->head) kl->head = *n;                               \
-        kltype_t d = p->data;                                           \
-        kmp_free(name, kl->mp, p);                                      \
-        return d;                                                       \
-    }                                                                   \
+#define KLIST_INIT(name, kltype_t, kmpfree_t) \
+    struct __kl1_##name { \
+        kltype_t data; \
+        struct __kl1_##name *next; \
+    }; \
+    typedef struct __kl1_##name kl1_##name; \
+    KMEMPOOL_INIT(name, kl1_##name, kmpfree_t) \
+    typedef struct { \
+        kl1_##name *head, *tail; \
+        kmp_##name##_t *mp; \
+        size_t size; \
+    } kl_##name##_t; \
+    static inline kl_##name##_t *kl_init_##name(void) { \
+        kl_##name##_t *kl = xcalloc(1, sizeof(kl_##name##_t)); \
+        kl->mp = kmp_init(name); \
+        kl->head = kl->tail = kmp_alloc(name, kl->mp); \
+        kl->head->next = 0; \
+        return kl; \
+    } \
+    static inline void kl_destroy_##name(kl_##name##_t *kl) \
+        REAL_FATTR_UNUSED; \
+    static inline void kl_destroy_##name(kl_##name##_t *kl) { \
+        kl1_##name *p; \
+        for (p = kl->head; p != kl->tail; p = p->next) \
+            kmp_free(name, kl->mp, p); \
+        kmp_free(name, kl->mp, p); \
+        kmp_destroy(name, kl->mp); \
+        xfree(kl); \
+    } \
+    static inline void kl_push_##name(kl_##name##_t *kl, kltype_t d) { \
+        kl1_##name *q, *p = kmp_alloc(name, kl->mp); \
+        q = kl->tail; p->next = 0; kl->tail->next = p; kl->tail = p; \
+        ++kl->size; \
+        q->data = d; \
+    } \
+    static inline kltype_t kl_shift_at_##name(kl_##name##_t *kl, \
+                                              kl1_##name **n) { \
+        assert((*n)->next); \
+        kl1_##name *p; \
+        --kl->size; \
+        p = *n; \
+        *n = (*n)->next; \
+        if (p == kl->head) kl->head = *n; \
+        kltype_t d = p->data; \
+        kmp_free(name, kl->mp, p); \
+        return d; \
+    } \
     
 
 #define kliter_t(name) kl1_##name
diff --git a/src/nvim/lib/queue.h b/src/nvim/lib/queue.h
index fc322978b0..9fcedf298f 100644
--- a/src/nvim/lib/queue.h
+++ b/src/nvim/lib/queue.h
@@ -25,7 +25,7 @@ typedef struct _queue {
 } QUEUE;
 
 // Public macros.
-#define QUEUE_DATA(ptr, type, field)  \
+#define QUEUE_DATA(ptr, type, field) \
   ((type *)((char *)(ptr) - offsetof(type, field)))
 
 #define QUEUE_FOREACH(q, h) \
diff --git a/src/nvim/lib/ringbuf.h b/src/nvim/lib/ringbuf.h
index cb71500bb7..12b75ec65a 100644
--- a/src/nvim/lib/ringbuf.h
+++ b/src/nvim/lib/ringbuf.h
@@ -65,12 +65,12 @@
 /// @param TypeName    Ring buffer type name. Actual type name will be
 ///                    `{TypeName}RingBuffer`.
 /// @param RBType      Type of the single ring buffer element.
-#define RINGBUF_TYPEDEF(TypeName, RBType)                                      \
-typedef struct {                                                               \
-  RBType *buf;                                                                 \
-  RBType *next;                                                                \
-  RBType *first;                                                               \
-  RBType *buf_end;                                                             \
+#define RINGBUF_TYPEDEF(TypeName, RBType) \
+typedef struct { \
+  RBType *buf; \
+  RBType *next; \
+  RBType *first; \
+  RBType *buf_end; \
 } TypeName##RingBuffer;
 
 /// Initialize a new ring buffer
@@ -84,198 +84,196 @@ typedef struct {                                                               \
 ///                    a macros like `#define RBFREE(item)` (to skip freeing).
 ///
 ///                    Intended function signature: `void *rbfree(RBType *)`;
-#define RINGBUF_INIT(TypeName, funcprefix, RBType, rbfree)                     \
-                                                                               \
-                                                                               \
-static inline TypeName##RingBuffer funcprefix##_rb_new(const size_t size)      \
-  REAL_FATTR_WARN_UNUSED_RESULT;                                               \
-static inline TypeName##RingBuffer funcprefix##_rb_new(const size_t size)      \
-{                                                                              \
-  assert(size != 0);                                                           \
-  RBType *buf = xmalloc(size * sizeof(RBType));                                \
-  return (TypeName##RingBuffer) {                                              \
-    .buf = buf,                                                                \
-    .next = buf,                                                               \
-    .first = NULL,                                                             \
-    .buf_end = buf + size - 1,                                                 \
-  };                                                                           \
-}                                                                              \
-                                                                               \
-static inline void funcprefix##_rb_free(TypeName##RingBuffer *const rb)        \
-  REAL_FATTR_UNUSED;                                                           \
-static inline void funcprefix##_rb_free(TypeName##RingBuffer *const rb)        \
-{                                                                              \
-  if (rb == NULL) {                                                            \
-    return;                                                                    \
-  }                                                                            \
-  RINGBUF_FORALL(rb, RBType, rbitem) {                                         \
-    rbfree(rbitem);                                                            \
-  }                                                                            \
-  xfree(rb->buf);                                                              \
-}                                                                              \
-                                                                               \
-static inline void funcprefix##_rb_dealloc(TypeName##RingBuffer *const rb)     \
-  REAL_FATTR_UNUSED;