refactor: format header files with uncrustify #15877

* refactor: format header files with uncrustify
* fixup(justin): skip formatting of terminfo_defs.h
* fixup: force winsock2 to be included first
* fixup: simplify disable/enable directive to "uncrustify:off/on"

34 files changed, 578 insertions, 603 deletions

diff --git a/src/nvim/api/private/defs.h b/src/nvim/api/private/defs.h
index 8346e01558..663d1e16b5 100644
--- a/src/nvim/api/private/defs.h
+++ b/src/nvim/api/private/defs.h
@@ -1,15 +1,15 @@
 #ifndef NVIM_API_PRIVATE_DEFS_H
 #define NVIM_API_PRIVATE_DEFS_H
 
-#include <stdint.h>
 #include <stdbool.h>
+#include <stdint.h>
 #include <string.h>
 
 #include "nvim/func_attr.h"
 #include "nvim/types.h"
 
-#define ARRAY_DICT_INIT {.size = 0, .capacity = 0, .items = NULL}
-#define STRING_INIT {.data = NULL, .size = 0}
+#define ARRAY_DICT_INIT { .size = 0, .capacity = 0, .items = NULL }
+#define STRING_INIT { .data = NULL, .size = 0 }
 #define OBJECT_INIT { .type = kObjectTypeNil }
 #define ERROR_INIT { .type = kErrorTypeNone, .msg = NULL }
 #define REMOTE_TYPE(type) typedef handle_T type
diff --git a/src/nvim/api/private/helpers.h b/src/nvim/api/private/helpers.h
index 2cdd80bffe..dc9452e832 100644
--- a/src/nvim/api/private/helpers.h
+++ b/src/nvim/api/private/helpers.h
@@ -4,12 +4,12 @@
 #include <stdbool.h>
 
 #include "nvim/api/private/defs.h"
-#include "nvim/vim.h"
-#include "nvim/getchar.h"
-#include "nvim/memory.h"
 #include "nvim/decoration.h"
 #include "nvim/ex_eval.h"
+#include "nvim/getchar.h"
 #include "nvim/lib/kvec.h"
+#include "nvim/memory.h"
+#include "nvim/vim.h"
 
 #define OBJECT_OBJ(o) o
 
@@ -76,7 +76,7 @@
   name.size = fixsize; \
   name.items = name##__items; \
 
-#define STATIC_CSTR_AS_STRING(s) ((String) {.data = s, .size = sizeof(s) - 1})
+#define STATIC_CSTR_AS_STRING(s) ((String) { .data = s, .size = sizeof(s) - 1 })
 
 /// Create a new String instance, putting data in allocated memory
 ///
@@ -137,7 +137,7 @@ typedef struct {
     msg_list = &private_msg_list; \
     private_msg_list = NULL; \
     code \
-    msg_list = saved_msg_list;  /* Restore the exception context. */ \
+      msg_list = saved_msg_list;  /* Restore the exception context. */ \
   } while (0)
 
 #ifdef INCLUDE_GENERATED_DECLARATIONS
diff --git a/src/nvim/eval/decode.h b/src/nvim/eval/decode.h
index 77fc4c78c2..f1be5a1f69 100644
--- a/src/nvim/eval/decode.h
+++ b/src/nvim/eval/decode.h
@@ -1,9 +1,8 @@
 #ifndef NVIM_EVAL_DECODE_H
 #define NVIM_EVAL_DECODE_H
 
-#include <stddef.h>
-
 #include <msgpack.h>
+#include <stddef.h>
 
 #include "nvim/eval/typval.h"
 #include "nvim/globals.h"
diff --git a/src/nvim/eval/encode.h b/src/nvim/eval/encode.h
index 596bb49ae0..8755ff48ac 100644
--- a/src/nvim/eval/encode.h
+++ b/src/nvim/eval/encode.h
@@ -1,9 +1,8 @@
 #ifndef NVIM_EVAL_ENCODE_H
 #define NVIM_EVAL_ENCODE_H
 
-#include <stddef.h>
-
 #include <msgpack.h>
+#include <stddef.h>
 
 #include "nvim/eval.h"
 #include "nvim/garray.h"
@@ -49,8 +48,7 @@ static inline ListReaderState encode_init_lrstate(const list_T *const list)
     .offset = 0,
     .li_length = (TV_LIST_ITEM_TV(tv_list_first(list))->vval.v_string == NULL
                   ? 0
-                  : STRLEN(TV_LIST_ITEM_TV(
-                      tv_list_first(list))->vval.v_string)),
+                  : STRLEN(TV_LIST_ITEM_TV(tv_list_first(list))->vval.v_string)),
   };
 }
 
diff --git a/src/nvim/eval/typval.h b/src/nvim/eval/typval.h
index 5aecaccee9..a28feffd0b 100644
--- a/src/nvim/eval/typval.h
+++ b/src/nvim/eval/typval.h
@@ -1,23 +1,23 @@
 #ifndef NVIM_EVAL_TYPVAL_H
 #define NVIM_EVAL_TYPVAL_H
 
+#include <assert.h>
 #include <inttypes.h>
+#include <stdbool.h>
 #include <stddef.h>
 #include <string.h>
-#include <stdbool.h>
-#include <assert.h>
 
-#include "nvim/types.h"
-#include "nvim/hashtab.h"
-#include "nvim/garray.h"
-#include "nvim/mbyte.h"
 #include "nvim/func_attr.h"
-#include "nvim/lib/queue.h"
-#include "nvim/profile.h"  // for proftime_T
-#include "nvim/pos.h"      // for linenr_T
+#include "nvim/garray.h"
 #include "nvim/gettext.h"
-#include "nvim/message.h"
+#include "nvim/hashtab.h"
+#include "nvim/lib/queue.h"
 #include "nvim/macros.h"
+#include "nvim/mbyte.h"
+#include "nvim/message.h"
+#include "nvim/pos.h"      // for linenr_T
+#include "nvim/profile.h"  // for proftime_T
+#include "nvim/types.h"
 #ifdef LOG_LIST_ACTIONS
 # include "nvim/memory.h"
 #endif
@@ -156,8 +156,8 @@ typedef enum {
 typedef struct listitem_S listitem_T;
 
 struct listitem_S {
-  listitem_T  *li_next;  ///< Next item in list.
-  listitem_T  *li_prev;  ///< Previous item in list.
+  listitem_T *li_next;  ///< Next item in list.
+  listitem_T *li_prev;  ///< Previous item in list.
   typval_T li_tv;  ///< Item value.
 };
 
@@ -195,25 +195,25 @@ typedef struct {
 } staticList10_T;
 
 #define TV_LIST_STATIC10_INIT { \
-    .sl_list = { \
-      .lv_first = NULL, \
-      .lv_last = NULL, \
-      .lv_refcount = 0, \
-      .lv_len = 0, \
-      .lv_watch = NULL, \
-      .lv_idx_item = NULL, \
-      .lv_lock = VAR_FIXED, \
-      .lv_used_next = NULL, \
-      .lv_used_prev = NULL, \
-    }, \
-  }
+  .sl_list = { \
+  .lv_first = NULL, \
+  .lv_last = NULL, \
+  .lv_refcount = 0, \
+  .lv_len = 0, \
+  .lv_watch = NULL, \
+  .lv_idx_item = NULL, \
+  .lv_lock = VAR_FIXED, \
+  .lv_used_next = NULL, \
+  .lv_used_prev = NULL, \
+  }, \
+}
 
 #define TV_DICTITEM_STRUCT(...) \
-    struct { \
-      typval_T di_tv;  /* Structure that holds scope dictionary itself. */ \
-      uint8_t di_flags;  /* Flags. */ \
-      char_u di_key[__VA_ARGS__];  /* Key value. */ \
-    }
+  struct { \
+    typval_T di_tv;  /* Structure that holds scope dictionary itself. */ \
+    uint8_t di_flags;  /* Flags. */ \
+    char_u di_key[__VA_ARGS__];  /* Key value. */ \
+  }
 
 /// Structure to hold a scope dictionary
 ///
@@ -321,40 +321,40 @@ struct funccall_S {
 
 /// Structure to hold info for a user function.
 struct ufunc {
-  int          uf_varargs;       ///< variable nr of arguments
-  int          uf_flags;
-  int          uf_calls;         ///< nr of active calls
-  bool         uf_cleared;       ///< func_clear() was already called
-  garray_T     uf_args;          ///< arguments
-  garray_T     uf_def_args;      ///< default argument expressions
-  garray_T     uf_lines;         ///< function lines
-  int          uf_profiling;     ///< true when func is being profiled
-  int          uf_prof_initialized;
+  int uf_varargs;       ///< variable nr of arguments
+  int uf_flags;
+  int uf_calls;         ///< nr of active calls
+  bool uf_cleared;       ///< func_clear() was already called
+  garray_T uf_args;          ///< arguments
+  garray_T uf_def_args;      ///< default argument expressions
+  garray_T uf_lines;         ///< function lines
+  int uf_profiling;     ///< true when func is being profiled
+  int uf_prof_initialized;
   // Managing cfuncs
-  cfunc_T      uf_cb;            ///< C function extension callback
+  cfunc_T uf_cb;            ///< C function extension callback
   cfunc_free_T uf_cb_free;       ///< C function extension free callback
-  void        *uf_cb_state;      ///< State of C function extension.
+  void *uf_cb_state;      ///< State of C function extension.
   // Profiling the function as a whole.
-  int          uf_tm_count;      ///< nr of calls
-  proftime_T   uf_tm_total;      ///< time spent in function + children
-  proftime_T   uf_tm_self;       ///< time spent in function itself
-  proftime_T   uf_tm_children;   ///< time spent in children this call
+  int uf_tm_count;      ///< nr of calls
+  proftime_T uf_tm_total;      ///< time spent in function + children
+  proftime_T uf_tm_self;       ///< time spent in function itself
+  proftime_T uf_tm_children;   ///< time spent in children this call
   // Profiling the function per line.
-  int         *uf_tml_count;     ///< nr of times line was executed
-  proftime_T  *uf_tml_total;     ///< time spent in a line + children
-  proftime_T  *uf_tml_self;      ///< time spent in a line itself
-  proftime_T   uf_tml_start;     ///< start time for current line
-  proftime_T   uf_tml_children;  ///< time spent in children for this line
-  proftime_T   uf_tml_wait;      ///< start wait time for current line
-  int          uf_tml_idx;       ///< index of line being timed; -1 if none
-  int          uf_tml_execed;    ///< line being timed was executed
-  sctx_T       uf_script_ctx;    ///< SCTX where function was defined,
-                                 ///< used for s: variables
-  int          uf_refcount;      ///< reference count, see func_name_refcount()
-  funccall_T   *uf_scoped;       ///< l: local variables for closure
-  char_u       uf_name[];  ///< Name of function (actual size equals name);
-                           ///< can start with <SNR>123_
-                           ///< (<SNR> is K_SPECIAL KS_EXTRA KE_SNR)
+  int *uf_tml_count;     ///< nr of times line was executed
+  proftime_T *uf_tml_total;     ///< time spent in a line + children
+  proftime_T *uf_tml_self;      ///< time spent in a line itself
+  proftime_T uf_tml_start;     ///< start time for current line
+  proftime_T uf_tml_children;  ///< time spent in children for this line
+  proftime_T uf_tml_wait;      ///< start wait time for current line
+  int uf_tml_idx;       ///< index of line being timed; -1 if none
+  int uf_tml_execed;    ///< line being timed was executed
+  sctx_T uf_script_ctx;    ///< SCTX where function was defined,
+                           ///< used for s: variables
+  int uf_refcount;      ///< reference count, see func_name_refcount()
+  funccall_T *uf_scoped;       ///< l: local variables for closure
+  char_u uf_name[];  ///< Name of function (actual size equals name);
+                     ///< can start with <SNR>123_
+                     ///< (<SNR> is K_SPECIAL KS_EXTRA KE_SNR)
 };
 
 struct partial_S {
@@ -452,10 +452,8 @@ static inline void list_log(const list_T *const l,
 /// @param[in]  li1  List item 1.
 /// @param[in]  li2  List item 2, often used for integers and not list items.
 /// @param[in]  action  Logged action.
-static inline void list_log(const list_T *const l,
-                            const listitem_T *const li1,
-                            const listitem_T *const li2,
-                            const char *const action)
+static inline void list_log(const list_T *const l, const listitem_T *const li1,
+                            const listitem_T *const li2, const char *const action)
 {
   ListLog *tgt;
   if (list_log_first == NULL) {
@@ -484,7 +482,7 @@ static inline void list_log(const list_T *const l,
 
 /// Convert a hashitem pointer to a dictitem pointer
 #define TV_DICT_HI2DI(hi) \
-    ((dictitem_T *)((hi)->hi_key - offsetof(dictitem_T, di_key)))
+  ((dictitem_T *)((hi)->hi_key - offsetof(dictitem_T, di_key)))
 
 static inline void tv_list_ref(list_T *const l)
   REAL_FATTR_ALWAYS_INLINE;
@@ -538,8 +536,7 @@ static inline VarLockStatus tv_list_locked(const list_T *const l)
 ///
 /// @param[out]  l  List to modify.
 /// @param[in]  lock  New lock status.
-static inline void tv_list_set_lock(list_T *const l,
-                                    const VarLockStatus lock)
+static inline void tv_list_set_lock(list_T *const l, const VarLockStatus lock)
 {
   if (l == NULL) {
     assert(lock == VAR_FIXED);
@@ -554,8 +551,7 @@ static inline void tv_list_set_lock(list_T *const l,
 ///
 /// @param[out]  l  List to modify.
 /// @param[in]  copyid  New copyID.
-static inline void tv_list_set_copyid(list_T *const l,
-                                      const int copyid)
+static inline void tv_list_set_copyid(list_T *const l, const int copyid)
   FUNC_ATTR_NONNULL_ALL
 {
   l->lv_copyID = copyid;
@@ -793,10 +789,10 @@ static inline void tv_init(typval_T *const tv)
 }
 
 #define TV_INITIAL_VALUE \
-    ((typval_T) { \
-      .v_type = VAR_UNKNOWN, \
-      .v_lock = VAR_UNLOCKED, \
-    })
+  ((typval_T) { \
+    .v_type = VAR_UNKNOWN, \
+    .v_lock = VAR_UNLOCKED, \
+  })
 
 /// Empty string
 ///
@@ -815,16 +811,16 @@ extern bool tv_in_free_unref_items;
 /// @param  li  Name of the variable with current listitem_T entry.
 /// @param  code  Cycle body.
 #define _TV_LIST_ITER_MOD(modifier, l, li, code) \
-    do { \
-      modifier list_T *const l_ = (l); \
-      list_log(l_, NULL, NULL, "iter" #modifier); \
-      if (l_ != NULL) { \
-        for (modifier listitem_T *li = l_->lv_first; \
-             li != NULL; li = li->li_next) { \
-          code \
-        } \
+  do { \
+    modifier list_T *const l_ = (l); \
+    list_log(l_, NULL, NULL, "iter" #modifier); \
+    if (l_ != NULL) { \
+      for (modifier listitem_T *li = l_->lv_first; \
+           li != NULL; li = li->li_next) { \
+        code \
       } \
-    } while (0)
+    } \
+  } while (0)
 
 /// Iterate over a list
 ///
@@ -835,7 +831,7 @@ extern bool tv_in_free_unref_items;
 /// @param  li  Name of the variable with current listitem_T entry.
 /// @param  code  Cycle body.
 #define TV_LIST_ITER(l, li, code) \
-    _TV_LIST_ITER_MOD(, l, li, code)
+  _TV_LIST_ITER_MOD(, l, li, code)
 
 /// Iterate over a list
 ///
@@ -846,7 +842,7 @@ extern bool tv_in_free_unref_items;
 /// @param  li  Name of the variable with current listitem_T entry.
 /// @param  code  Cycle body.
 #define TV_LIST_ITER_CONST(l, li, code) \
-    _TV_LIST_ITER_MOD(const, l, li, code)
+  _TV_LIST_ITER_MOD(const, l, li, code)
 
 // Below macros are macros to avoid duplicating code for functionally identical
 // const and non-const function variants.
@@ -883,14 +879,14 @@ extern bool tv_in_free_unref_items;
 /// @param  di  Name of the variable with current dictitem_T entry.
 /// @param  code  Cycle body.
 #define TV_DICT_ITER(d, di, code) \
-    HASHTAB_ITER(&(d)->dv_hashtab, di##hi_, { \
+  HASHTAB_ITER(&(d)->dv_hashtab, di##hi_, { \
+    { \
+      dictitem_T *const di = TV_DICT_HI2DI(di##hi_); \
       { \
-        dictitem_T *const di = TV_DICT_HI2DI(di##hi_); \
-        { \
-          code \
-        } \
+        code \
       } \
-    })
+    } \
+  })
 
 static inline bool tv_get_float_chk(const typval_T *const tv,
                                     float_T *const ret_f)
@@ -907,8 +903,7 @@ bool emsgf(const char *const fmt, ...);
 /// @param[out]  ret_f  Location where resulting float is stored.
 ///
 /// @return true in case of success, false if tv is not a number or float.
-static inline bool tv_get_float_chk(const typval_T *const tv,
-                                    float_T *const ret_f)
+static inline bool tv_get_float_chk(const typval_T *const tv, float_T *const ret_f)
 {
   if (tv->v_type == VAR_FLOAT) {
     *ret_f = tv->vval.v_float;
diff --git a/src/nvim/eval/typval_encode.c.h b/src/nvim/eval/typval_encode.c.h
index cd1be1eecc..ece51cb046 100644
--- a/src/nvim/eval/typval_encode.c.h
+++ b/src/nvim/eval/typval_encode.c.h
@@ -240,15 +240,15 @@
 ///
 /// This name will only be used by one of the above macros which are defined by
 /// the caller. Functions defined here do not use first argument directly.
-#include <stddef.h>
-#include <inttypes.h>
 #include <assert.h>
+#include <inttypes.h>
+#include <stddef.h>
 
-#include "nvim/lib/kvec.h"
-#include "nvim/eval/typval.h"
 #include "nvim/eval/encode.h"
-#include "nvim/func_attr.h"
+#include "nvim/eval/typval.h"
 #include "nvim/eval/typval_encode.h"
+#include "nvim/func_attr.h"
+#include "nvim/lib/kvec.h"
 
 /// Dummy variable used because some macros need lvalue
 ///
@@ -257,12 +257,12 @@
 const dict_T *const TYPVAL_ENCODE_NODICT_VAR = NULL;
 
 static inline int _TYPVAL_ENCODE_CHECK_SELF_REFERENCE(
-    TYPVAL_ENCODE_FIRST_ARG_TYPE TYPVAL_ENCODE_FIRST_ARG_NAME,
-    void *const val, int *const val_copyID,
-    const MPConvStack *const mpstack, const int copyID,
-    const MPConvStackValType conv_type,
-    const char *const objname)
-  REAL_FATTR_NONNULL_ARG(2, 3, 4, 7) REAL_FATTR_WARN_UNUSED_RESULT
+                                                      TYPVAL_ENCODE_FIRST_ARG_TYPE TYPVAL_ENCODE_FIRST_ARG_NAME,
+                                                      void *const val, int *const val_copyID,
+                                                      const MPConvStack *const mpstack, const int copyID,
+                                                      const MPConvStackValType conv_type,
+                                                      const char *const objname)
+REAL_FATTR_NONNULL_ARG(2, 3, 4, 7) REAL_FATTR_WARN_UNUSED_RESULT
   REAL_FATTR_ALWAYS_INLINE;
 
 /// Function for checking whether container references itself
@@ -280,11 +280,9 @@ static inline int _TYPVAL_ENCODE_CHECK_SELF_REFERENCE(
 ///
 /// @return NOTDONE in case of success, what to return in case of failure.
 static inline int _TYPVAL_ENCODE_CHECK_SELF_REFERENCE(
-    TYPVAL_ENCODE_FIRST_ARG_TYPE TYPVAL_ENCODE_FIRST_ARG_NAME,
-    void *const val, int *const val_copyID,
-    const MPConvStack *const mpstack, const int copyID,
-    const MPConvStackValType conv_type,
-    const char *const objname)
+                                                     TYPVAL_ENCODE_FIRST_ARG_TYPE TYPVAL_ENCODE_FIRST_ARG_NAME, void *const val, int *const val_copyID,
+                                                     const MPConvStack *const mpstack, const int copyID, const MPConvStackValType conv_type,
+                                                     const char *const objname)
 {
   if (*val_copyID == copyID) {
     TYPVAL_ENCODE_CONV_RECURSE(val, conv_type);
@@ -295,11 +293,11 @@ static inline int _TYPVAL_ENCODE_CHECK_SELF_REFERENCE(
 }
 
 static int _TYPVAL_ENCODE_CONVERT_ONE_VALUE(
-    TYPVAL_ENCODE_FIRST_ARG_TYPE TYPVAL_ENCODE_FIRST_ARG_NAME,
-    MPConvStack *const mpstack, MPConvStackVal *const cur_mpsv,
-    typval_T *const tv, const int copyID,
-    const char *const objname)
-  REAL_FATTR_NONNULL_ARG(2, 4, 6) REAL_FATTR_WARN_UNUSED_RESULT;
+                                            TYPVAL_ENCODE_FIRST_ARG_TYPE TYPVAL_ENCODE_FIRST_ARG_NAME,
+                                            MPConvStack *const mpstack, MPConvStackVal *const cur_mpsv,
+                                            typval_T *const tv, const int copyID,
+                                            const char *const objname)
+REAL_FATTR_NONNULL_ARG(2, 4, 6) REAL_FATTR_WARN_UNUSED_RESULT;
 
 /// Convert single value
 ///
@@ -319,42 +317,35 @@ static int _TYPVAL_ENCODE_CONVERT_ONE_VALUE(
 ///
 /// @return OK in case of success, FAIL in case of failure.
 static int _TYPVAL_ENCODE_CONVERT_ONE_VALUE(
-    TYPVAL_ENCODE_FIRST_ARG_TYPE TYPVAL_ENCODE_FIRST_ARG_NAME,
-    MPConvStack *const mpstack, MPConvStackVal *const cur_mpsv,
-    typval_T *const tv, const int copyID,
-    const char *const objname)
+                                           TYPVAL_ENCODE_FIRST_ARG_TYPE TYPVAL_ENCODE_FIRST_ARG_NAME, MPConvStack *const mpstack,
+                                           MPConvStackVal *const cur_mpsv, typval_T *const tv, const int copyID, const char *const objname)
 {
   switch (tv->v_type) {
-    case VAR_STRING: {
-      TYPVAL_ENCODE_CONV_STRING(tv, tv->vval.v_string, tv_strlen(tv));
-      break;
-    }
-    case VAR_NUMBER: {
-      TYPVAL_ENCODE_CONV_NUMBER(tv, tv->vval.v_number);
-      break;
-    }
-    case VAR_FLOAT: {
-      TYPVAL_ENCODE_CONV_FLOAT(tv, tv->vval.v_float);
-      break;
-    }
-    case VAR_BLOB: {
-      TYPVAL_ENCODE_CONV_BLOB(tv, tv->vval.v_blob,
-                              tv_blob_len(tv->vval.v_blob));
-      break;
-    }
-    case VAR_FUNC: {
-      TYPVAL_ENCODE_CONV_FUNC_START(tv, tv->vval.v_string);
-      TYPVAL_ENCODE_CONV_FUNC_BEFORE_ARGS(tv, 0);
-      TYPVAL_ENCODE_CONV_FUNC_BEFORE_SELF(tv, -1);
-      TYPVAL_ENCODE_CONV_FUNC_END(tv);
-      break;
-    }
-    case VAR_PARTIAL: {
-      partial_T *const pt = tv->vval.v_partial;
-      (void)pt;
-      TYPVAL_ENCODE_CONV_FUNC_START(  // -V547
-          tv, (pt == NULL ? NULL : partial_name(pt)));
-      _mp_push(*mpstack, ((MPConvStackVal) {  // -V779
+  case VAR_STRING:
+    TYPVAL_ENCODE_CONV_STRING(tv, tv->vval.v_string, tv_strlen(tv));
+    break;
+  case VAR_NUMBER:
+    TYPVAL_ENCODE_CONV_NUMBER(tv, tv->vval.v_number);
+    break;
+  case VAR_FLOAT:
+    TYPVAL_ENCODE_CONV_FLOAT(tv, tv->vval.v_float);
+    break;
+  case VAR_BLOB:
+    TYPVAL_ENCODE_CONV_BLOB(tv, tv->vval.v_blob,
+                            tv_blob_len(tv->vval.v_blob));
+    break;
+  case VAR_FUNC:
+    TYPVAL_ENCODE_CONV_FUNC_START(tv, tv->vval.v_string);
+    TYPVAL_ENCODE_CONV_FUNC_BEFORE_ARGS(tv, 0);
+    TYPVAL_ENCODE_CONV_FUNC_BEFORE_SELF(tv, -1);
+    TYPVAL_ENCODE_CONV_FUNC_END(tv);
+    break;
+  case VAR_PARTIAL: {
+    partial_T *const pt = tv->vval.v_partial;
+    (void)pt;
+    TYPVAL_ENCODE_CONV_FUNC_START(  // -V547
+                                    tv, (pt == NULL ? NULL : partial_name(pt)));
+    _mp_push(*mpstack, ((MPConvStackVal) {  // -V779
         .type = kMPConvPartial,
         .tv = tv,
         .saved_copyID = copyID - 1,
@@ -365,19 +356,19 @@ static int _TYPVAL_ENCODE_CONVERT_ONE_VALUE(
           },
         },
       }));
+    break;
+  }
+  case VAR_LIST: {
+    if (tv->vval.v_list == NULL || tv_list_len(tv->vval.v_list) == 0) {
+      TYPVAL_ENCODE_CONV_EMPTY_LIST(tv);
       break;
     }
-    case VAR_LIST: {
-      if (tv->vval.v_list == NULL || tv_list_len(tv->vval.v_list) == 0) {
-        TYPVAL_ENCODE_CONV_EMPTY_LIST(tv);
-        break;
-      }
-      const int saved_copyID = tv_list_copyid(tv->vval.v_list);
-      _TYPVAL_ENCODE_DO_CHECK_SELF_REFERENCE(tv->vval.v_list, lv_copyID, copyID,
-                                             kMPConvList);
-      TYPVAL_ENCODE_CONV_LIST_START(tv, tv_list_len(tv->vval.v_list));
-      assert(saved_copyID != copyID);
-      _mp_push(*mpstack, ((MPConvStackVal) {
+    const int saved_copyID = tv_list_copyid(tv->vval.v_list);
+    _TYPVAL_ENCODE_DO_CHECK_SELF_REFERENCE(tv->vval.v_list, lv_copyID, copyID,
+                                           kMPConvList);
+    TYPVAL_ENCODE_CONV_LIST_START(tv, tv_list_len(tv->vval.v_list));
+    assert(saved_copyID != copyID);
+    _mp_push(*mpstack, ((MPConvStackVal) {
         .type = kMPConvList,
         .tv = tv,
         .saved_copyID = saved_copyID,
@@ -388,159 +379,151 @@ static int _TYPVAL_ENCODE_CONVERT_ONE_VALUE(
           },
         },
       }));
-      TYPVAL_ENCODE_CONV_REAL_LIST_AFTER_START(tv, _mp_last(*mpstack));
+    TYPVAL_ENCODE_CONV_REAL_LIST_AFTER_START(tv, _mp_last(*mpstack));
+    break;
+  }
+  case VAR_BOOL:
+    switch (tv->vval.v_bool) {
+    case kBoolVarTrue:
+    case kBoolVarFalse:
+      TYPVAL_ENCODE_CONV_BOOL(tv, tv->vval.v_bool == kBoolVarTrue);
       break;
     }
-    case VAR_BOOL: {
-      switch (tv->vval.v_bool) {
-        case kBoolVarTrue:
-        case kBoolVarFalse: {
-          TYPVAL_ENCODE_CONV_BOOL(tv, tv->vval.v_bool == kBoolVarTrue);
-          break;
-        }
-      }
+    break;
+  case VAR_SPECIAL:
+    switch (tv->vval.v_special) {
+    case kSpecialVarNull:
+      TYPVAL_ENCODE_CONV_NIL(tv);  // -V1037
       break;
     }
-    case VAR_SPECIAL: {
-      switch (tv->vval.v_special) {
-        case kSpecialVarNull: {
-          TYPVAL_ENCODE_CONV_NIL(tv);  // -V1037
+    break;
+  case VAR_DICT: {
+    if (tv->vval.v_dict == NULL
+        || tv->vval.v_dict->dv_hashtab.ht_used == 0) {
+      TYPVAL_ENCODE_CONV_EMPTY_DICT(tv, tv->vval.v_dict);
+      break;
+    }
+    const dictitem_T *type_di;
+    const dictitem_T *val_di;
+    if (TYPVAL_ENCODE_ALLOW_SPECIALS
+        && tv->vval.v_dict->dv_hashtab.ht_used == 2
+        && (type_di = tv_dict_find((dict_T *)tv->vval.v_dict,
+                                   S_LEN("_TYPE"))) != NULL
+        && type_di->di_tv.v_type == VAR_LIST
+        && (val_di = tv_dict_find((dict_T *)tv->vval.v_dict,
+                                  S_LEN("_VAL"))) != NULL) {
+      size_t i;
+      for (i = 0; i < ARRAY_SIZE(eval_msgpack_type_lists); i++) {
+        if (type_di->di_tv.vval.v_list == eval_msgpack_type_lists[i]) {
           break;
         }
       }
-      break;
-    }
-    case VAR_DICT: {
-      if (tv->vval.v_dict == NULL
-          || tv->vval.v_dict->dv_hashtab.ht_used == 0) {
-        TYPVAL_ENCODE_CONV_EMPTY_DICT(tv, tv->vval.v_dict);
-        break;
+      if (i == ARRAY_SIZE(eval_msgpack_type_lists)) {
+        goto _convert_one_value_regular_dict;
       }
-      const dictitem_T *type_di;
-      const dictitem_T *val_di;
-      if (TYPVAL_ENCODE_ALLOW_SPECIALS
-          && tv->vval.v_dict->dv_hashtab.ht_used == 2
-          && (type_di = tv_dict_find((dict_T *)tv->vval.v_dict,
-                                     S_LEN("_TYPE"))) != NULL
-          && type_di->di_tv.v_type == VAR_LIST
-          && (val_di = tv_dict_find((dict_T *)tv->vval.v_dict,
-                                    S_LEN("_VAL"))) != NULL) {
-        size_t i;
-        for (i = 0; i < ARRAY_SIZE(eval_msgpack_type_lists); i++) {
-          if (type_di->di_tv.vval.v_list == eval_msgpack_type_lists[i]) {
-            break;
-          }
+      switch ((MessagePackType)i) {
+      case kMPNil:
+        TYPVAL_ENCODE_CONV_NIL(tv);
+        break;
+      case kMPBoolean:
+        if (val_di->di_tv.v_type != VAR_NUMBER) {
+          goto _convert_one_value_regular_dict;
         }
-        if (i == ARRAY_SIZE(eval_msgpack_type_lists)) {
+        TYPVAL_ENCODE_CONV_BOOL(tv, val_di->di_tv.vval.v_number);
+        break;
+      case kMPInteger: {
+        const list_T *val_list;
+        varnumber_T sign;
+        varnumber_T highest_bits;
+        varnumber_T high_bits;
+        varnumber_T low_bits;
+        // List of 4 integers; first is signed (should be 1 or -1, but
+        // this is not checked), second is unsigned and have at most
+        // one (sign is -1) or two (sign is 1) non-zero bits (number of
+        // bits is not checked), other unsigned and have at most 31
+        // non-zero bits (number of bits is not checked).
+        if (val_di->di_tv.v_type != VAR_LIST
+            || tv_list_len(val_list = val_di->di_tv.vval.v_list) != 4) {
           goto _convert_one_value_regular_dict;
         }
-        switch ((MessagePackType)i) {
-          case kMPNil: {
-            TYPVAL_ENCODE_CONV_NIL(tv);
-            break;
-          }
-          case kMPBoolean: {
-            if (val_di->di_tv.v_type != VAR_NUMBER) {
-              goto _convert_one_value_regular_dict;
-            }
-            TYPVAL_ENCODE_CONV_BOOL(tv, val_di->di_tv.vval.v_number);
-            break;
-          }
-          case kMPInteger: {
-            const list_T *val_list;
-            varnumber_T sign;
-            varnumber_T highest_bits;
-            varnumber_T high_bits;
-            varnumber_T low_bits;
-            // List of 4 integers; first is signed (should be 1 or -1, but
-            // this is not checked), second is unsigned and have at most
-            // one (sign is -1) or two (sign is 1) non-zero bits (number of
-            // bits is not checked), other unsigned and have at most 31
-            // non-zero bits (number of bits is not checked).
-            if (val_di->di_tv.v_type != VAR_LIST
-                || tv_list_len(val_list = val_di->di_tv.vval.v_list) != 4) {
-              goto _convert_one_value_regular_dict;
-            }
 
-            const listitem_T *const sign_li = tv_list_first(val_list);
-            if (TV_LIST_ITEM_TV(sign_li)->v_type != VAR_NUMBER
-                || (sign = TV_LIST_ITEM_TV(sign_li)->vval.v_number) == 0) {
-              goto _convert_one_value_regular_dict;
-            }
+        const listitem_T *const sign_li = tv_list_first(val_list);
+        if (TV_LIST_ITEM_TV(sign_li)->v_type != VAR_NUMBER
+            || (sign = TV_LIST_ITEM_TV(sign_li)->vval.v_number) == 0) {
+          goto _convert_one_value_regular_dict;
+        }
 
-            const listitem_T *const highest_bits_li = (
-                TV_LIST_ITEM_NEXT(val_list, sign_li));
-            if (TV_LIST_ITEM_TV(highest_bits_li)->v_type != VAR_NUMBER
-                || ((highest_bits
-                     = TV_LIST_ITEM_TV(highest_bits_li)->vval.v_number)
-                    < 0)) {
-              goto _convert_one_value_regular_dict;
-            }
+        const listitem_T *const highest_bits_li = (
+                                                   TV_LIST_ITEM_NEXT(val_list, sign_li));
+        if (TV_LIST_ITEM_TV(highest_bits_li)->v_type != VAR_NUMBER
+            || ((highest_bits
+                   = TV_LIST_ITEM_TV(highest_bits_li)->vval.v_number)
+                < 0)) {
+          goto _convert_one_value_regular_dict;
+        }
 
-            const listitem_T *const high_bits_li =  (
-                TV_LIST_ITEM_NEXT(val_list, highest_bits_li));
-            if (TV_LIST_ITEM_TV(high_bits_li)->v_type != VAR_NUMBER
-                || ((high_bits = TV_LIST_ITEM_TV(high_bits_li)->vval.v_number)
-                    < 0)) {
-              goto _convert_one_value_regular_dict;
-            }
+        const listitem_T *const high_bits_li =  (
+                                                 TV_LIST_ITEM_NEXT(val_list, highest_bits_li));
+        if (TV_LIST_ITEM_TV(high_bits_li)->v_type != VAR_NUMBER
+            || ((high_bits = TV_LIST_ITEM_TV(high_bits_li)->vval.v_number)
+                < 0)) {
+          goto _convert_one_value_regular_dict;
+        }
 
-            const listitem_T *const low_bits_li = tv_list_last(val_list);
-            if (TV_LIST_ITEM_TV(low_bits_li)->v_type != VAR_NUMBER
-                || ((low_bits = TV_LIST_ITEM_TV(low_bits_li)->vval.v_number)
-                    < 0)) {
-              goto _convert_one_value_regular_dict;
-            }
+        const listitem_T *const low_bits_li = tv_list_last(val_list);
+        if (TV_LIST_ITEM_TV(low_bits_li)->v_type != VAR_NUMBER
+            || ((low_bits = TV_LIST_ITEM_TV(low_bits_li)->vval.v_number)
+                < 0)) {
+          goto _convert_one_value_regular_dict;
+        }
 
-            const uint64_t number = ((uint64_t)(((uint64_t)highest_bits) << 62)
-                                     | (uint64_t)(((uint64_t)high_bits) << 31)
-                                     | (uint64_t)low_bits);
-            if (sign > 0) {
-              TYPVAL_ENCODE_CONV_UNSIGNED_NUMBER(tv, number);
-            } else {
-              TYPVAL_ENCODE_CONV_NUMBER(tv, -number);
-            }
-            break;
-          }
-          case kMPFloat: {
-            if (val_di->di_tv.v_type != VAR_FLOAT) {
-              goto _convert_one_value_regular_dict;
-            }
-            TYPVAL_ENCODE_CONV_FLOAT(tv, val_di->di_tv.vval.v_float);
-            break;
-          }
-          case kMPString:
-          case kMPBinary: {
-            const bool is_string = ((MessagePackType)i == kMPString);
-            if (val_di->di_tv.v_type != VAR_LIST) {
-              goto _convert_one_value_regular_dict;
-            }
-            size_t len;
-            char *buf;
-            if (!encode_vim_list_to_buf(val_di->di_tv.vval.v_list, &len,
-                                        &buf)) {
-              goto _convert_one_value_regular_dict;
-            }
-            if (is_string) {
-              TYPVAL_ENCODE_CONV_STR_STRING(tv, buf, len);
-            } else {  // -V523
-              TYPVAL_ENCODE_CONV_STRING(tv, buf, len);
-            }
-            xfree(buf);
-            break;
-          }
-          case kMPArray: {
-            if (val_di->di_tv.v_type != VAR_LIST) {
-              goto _convert_one_value_regular_dict;
-            }
-            const int saved_copyID = tv_list_copyid(val_di->di_tv.vval.v_list);
-            _TYPVAL_ENCODE_DO_CHECK_SELF_REFERENCE(val_di->di_tv.vval.v_list,
-                                                   lv_copyID, copyID,
-                                                   kMPConvList);
-            TYPVAL_ENCODE_CONV_LIST_START(
-                tv, tv_list_len(val_di->di_tv.vval.v_list));
-            assert(saved_copyID != copyID && saved_copyID != copyID - 1);
-            _mp_push(*mpstack, ((MPConvStackVal) {
+        const uint64_t number = ((uint64_t)(((uint64_t)highest_bits) << 62)
+                                 | (uint64_t)(((uint64_t)high_bits) << 31)
+                                 | (uint64_t)low_bits);
+        if (sign > 0) {
+          TYPVAL_ENCODE_CONV_UNSIGNED_NUMBER(tv, number);
+        } else {
+          TYPVAL_ENCODE_CONV_NUMBER(tv, -number);
+        }
+        break;
+      }
+      case kMPFloat:
+        if (val_di->di_tv.v_type != VAR_FLOAT) {
+          goto _convert_one_value_regular_dict;
+        }
+        TYPVAL_ENCODE_CONV_FLOAT(tv, val_di->di_tv.vval.v_float);
+        break;
+      case kMPString:
+      case kMPBinary: {
+        const bool is_string = ((MessagePackType)i == kMPString);
+        if (val_di->di_tv.v_type != VAR_LIST) {
+          goto _convert_one_value_regular_dict;
+        }
+        size_t len;
+        char *buf;
+        if (!encode_vim_list_to_buf(val_di->di_tv.vval.v_list, &len,
+                                    &buf)) {
+          goto _convert_one_value_regular_dict;
+        }
+        if (is_string) {
+          TYPVAL_ENCODE_CONV_STR_STRING(tv, buf, len);
+        } else {  // -V523
+          TYPVAL_ENCODE_CONV_STRING(tv, buf, len);
+        }
+        xfree(buf);
+        break;
+      }
+      case kMPArray: {
+        if (val_di->di_tv.v_type != VAR_LIST) {
+          goto _convert_one_value_regular_dict;
+        }
+        const int saved_copyID = tv_list_copyid(val_di->di_tv.vval.v_list);
+        _TYPVAL_ENCODE_DO_CHECK_SELF_REFERENCE(val_di->di_tv.vval.v_list,
+                                               lv_copyID, copyID,
+                                               kMPConvList);
+        TYPVAL_ENCODE_CONV_LIST_START(tv, tv_list_len(val_di->di_tv.vval.v_list));
+        assert(saved_copyID != copyID && saved_copyID != copyID - 1);
+        _mp_push(*mpstack, ((MPConvStackVal) {
               .tv = tv,
               .type = kMPConvList,
               .saved_copyID = saved_copyID,
@@ -551,31 +534,31 @@ static int _TYPVAL_ENCODE_CONVERT_ONE_VALUE(
                 },
               },
             }));
-            break;
-          }
-          case kMPMap: {
-            if (val_di->di_tv.v_type != VAR_LIST) {
-              goto _convert_one_value_regular_dict;
-            }
-            list_T *const val_list = val_di->di_tv.vval.v_list;
-            if (val_list == NULL || tv_list_len(val_list) == 0) {
-              TYPVAL_ENCODE_CONV_EMPTY_DICT(  // -V501
-                  tv, TYPVAL_ENCODE_NODICT_VAR);
-              break;
-            }
-            TV_LIST_ITER_CONST(val_list, li, {
+        break;
+      }
+      case kMPMap: {
+        if (val_di->di_tv.v_type != VAR_LIST) {
+          goto _convert_one_value_regular_dict;
+        }
+        list_T *const val_list = val_di->di_tv.vval.v_list;
+        if (val_list == NULL || tv_list_len(val_list) == 0) {
+          TYPVAL_ENCODE_CONV_EMPTY_DICT(  // -V501
+                                          tv, TYPVAL_ENCODE_NODICT_VAR);
+          break;
+        }
+        TV_LIST_ITER_CONST(val_list, li, {
               if (TV_LIST_ITEM_TV(li)->v_type != VAR_LIST
                   || tv_list_len(TV_LIST_ITEM_TV(li)->vval.v_list) != 2) {
                 goto _convert_one_value_regular_dict;
               }
             });
-            const int saved_copyID = tv_list_copyid(val_di->di_tv.vval.v_list);
-            _TYPVAL_ENCODE_DO_CHECK_SELF_REFERENCE(val_list, lv_copyID, copyID,
-                                                   kMPConvPairs);
-            TYPVAL_ENCODE_CONV_DICT_START(tv, TYPVAL_ENCODE_NODICT_VAR,
-                                          tv_list_len(val_list));
-            assert(saved_copyID != copyID && saved_copyID != copyID - 1);
-            _mp_push(*mpstack, ((MPConvStackVal) {
+        const int saved_copyID = tv_list_copyid(val_di->di_tv.vval.v_list);
+        _TYPVAL_ENCODE_DO_CHECK_SELF_REFERENCE(val_list, lv_copyID, copyID,
+                                               kMPConvPairs);
+        TYPVAL_ENCODE_CONV_DICT_START(tv, TYPVAL_ENCODE_NODICT_VAR,
+                                      tv_list_len(val_list));
+        assert(saved_copyID != copyID && saved_copyID != copyID - 1);
+        _mp_push(*mpstack, ((MPConvStackVal) {
               .tv = tv,
               .type = kMPConvPairs,
               .saved_copyID = saved_copyID,
@@ -586,46 +569,45 @@ static int _TYPVAL_ENCODE_CONVERT_ONE_VALUE(
                 },
               },
             }));
-            break;
-          }
-          case kMPExt: {
-            const list_T *val_list;
-            varnumber_T type;
-            if (val_di->di_tv.v_type != VAR_LIST
-                || tv_list_len((val_list = val_di->di_tv.vval.v_list)) != 2
-                || (TV_LIST_ITEM_TV(tv_list_first(val_list))->v_type
-                    != VAR_NUMBER)
-                || ((type
-                     = TV_LIST_ITEM_TV(tv_list_first(val_list))->vval.v_number)
-                    > INT8_MAX)
-                || type < INT8_MIN
-                || (TV_LIST_ITEM_TV(tv_list_last(val_list))->v_type
-                    != VAR_LIST)) {
-              goto _convert_one_value_regular_dict;
-            }
-            size_t len;
-            char *buf;
-            if (!(
-                encode_vim_list_to_buf(
-                    TV_LIST_ITEM_TV(tv_list_last(val_list))->vval.v_list, &len,
-                    &buf))) {
-              goto _convert_one_value_regular_dict;
-            }
-            TYPVAL_ENCODE_CONV_EXT_STRING(tv, buf, len, type);
-            xfree(buf);
-            break;
-          }
+        break;
+      }
+      case kMPExt: {
+        const list_T *val_list;
+        varnumber_T type;
+        if (val_di->di_tv.v_type != VAR_LIST
+            || tv_list_len((val_list = val_di->di_tv.vval.v_list)) != 2
+            || (TV_LIST_ITEM_TV(tv_list_first(val_list))->v_type
+                != VAR_NUMBER)
+            || ((type
+                   = TV_LIST_ITEM_TV(tv_list_first(val_list))->vval.v_number)
+                > INT8_MAX)
+            || type < INT8_MIN
+            || (TV_LIST_ITEM_TV(tv_list_last(val_list))->v_type
+                != VAR_LIST)) {
+          goto _convert_one_value_regular_dict;
+        }
+        size_t len;
+        char *buf;
+        if (!(
+              encode_vim_list_to_buf(TV_LIST_ITEM_TV(tv_list_last(val_list))->vval.v_list, &len,
+                                     &buf))) {
+          goto _convert_one_value_regular_dict;
         }
+        TYPVAL_ENCODE_CONV_EXT_STRING(tv, buf, len, type);
+        xfree(buf);
         break;
       }
+      }
+      break;
+    }
 _convert_one_value_regular_dict: {}
-      const int saved_copyID = tv->vval.v_dict->dv_copyID;
-      _TYPVAL_ENCODE_DO_CHECK_SELF_REFERENCE(tv->vval.v_dict, dv_copyID, copyID,
-                                             kMPConvDict);
-      TYPVAL_ENCODE_CONV_DICT_START(tv, tv->vval.v_dict,
-                                    tv->vval.v_dict->dv_hashtab.ht_used);
-      assert(saved_copyID != copyID);
-      _mp_push(*mpstack, ((MPConvStackVal) {
+    const int saved_copyID = tv->vval.v_dict->dv_copyID;
+    _TYPVAL_ENCODE_DO_CHECK_SELF_REFERENCE(tv->vval.v_dict, dv_copyID, copyID,
+                                           kMPConvDict);
+    TYPVAL_ENCODE_CONV_DICT_START(tv, tv->vval.v_dict,
+                                  tv->vval.v_dict->dv_hashtab.ht_used);
+    assert(saved_copyID != copyID);
+    _mp_push(*mpstack, ((MPConvStackVal) {
         .tv = tv,
         .type = kMPConvDict,
         .saved_copyID = saved_copyID,
@@ -638,14 +620,13 @@ _convert_one_value_regular_dict: {}
           },
         },
       }));
-      TYPVAL_ENCODE_CONV_REAL_DICT_AFTER_START(tv, tv->vval.v_dict,
-                                               _mp_last(*mpstack));
-      break;
-    }
-    case VAR_UNKNOWN: {
-      internal_error(STR(_TYPVAL_ENCODE_CONVERT_ONE_VALUE) "()");
-      return FAIL;
-    }
+    TYPVAL_ENCODE_CONV_REAL_DICT_AFTER_START(tv, tv->vval.v_dict,
+                                             _mp_last(*mpstack));
+    break;
+  }
+  case VAR_UNKNOWN:
+    internal_error(STR(_TYPVAL_ENCODE_CONVERT_ONE_VALUE) "()");
+    return FAIL;
   }
 typval_encode_stop_converting_one_item:
   return OK;
@@ -654,9 +635,9 @@ typval_encode_stop_converting_one_item:
 }
 
 TYPVAL_ENCODE_SCOPE int _TYPVAL_ENCODE_ENCODE(
-    TYPVAL_ENCODE_FIRST_ARG_TYPE TYPVAL_ENCODE_FIRST_ARG_NAME,
-    typval_T *const tv, const char *const objname)
-  REAL_FATTR_NONNULL_ARG(2, 3) REAL_FATTR_WARN_UNUSED_RESULT;
+                                              TYPVAL_ENCODE_FIRST_ARG_TYPE TYPVAL_ENCODE_FIRST_ARG_NAME,
+                                              typval_T *const tv, const char *const objname)
+REAL_FATTR_NONNULL_ARG(2, 3) REAL_FATTR_WARN_UNUSED_RESULT;
 
 /// Convert the whole typval
 ///
@@ -668,8 +649,8 @@ TYPVAL_ENCODE_SCOPE int _TYPVAL_ENCODE_ENCODE(
 ///
 /// @return OK in case of success, FAIL in case of failure.
 TYPVAL_ENCODE_SCOPE int _TYPVAL_ENCODE_ENCODE(
-    TYPVAL_ENCODE_FIRST_ARG_TYPE TYPVAL_ENCODE_FIRST_ARG_NAME,
-    typval_T *const top_tv, const char *const objname)
+                                             TYPVAL_ENCODE_FIRST_ARG_TYPE TYPVAL_ENCODE_FIRST_ARG_NAME, typval_T *const top_tv,
+                                             const char *const objname)
 {
   const int copyID = get_copyID();
   MPConvStack mpstack;
@@ -687,125 +668,121 @@ typval_encode_stop_converting_one_item:
     MPConvStackVal *cur_mpsv = &_mp_last(mpstack);
     typval_T *tv = NULL;
     switch (cur_mpsv->type) {
-      case kMPConvDict: {
-        if (!cur_mpsv->data.d.todo) {
-          (void)_mp_pop(mpstack);
-          cur_mpsv->data.d.dict->dv_copyID = cur_mpsv->saved_copyID;
-          TYPVAL_ENCODE_CONV_DICT_END(cur_mpsv->tv, *cur_mpsv->data.d.dictp);
-          continue;
-        } else if (cur_mpsv->data.d.todo
-                   != cur_mpsv->data.d.dict->dv_hashtab.ht_used) {
-          TYPVAL_ENCODE_CONV_DICT_BETWEEN_ITEMS(cur_mpsv->tv,
-                                                *cur_mpsv->data.d.dictp);
-        }
-        while (HASHITEM_EMPTY(cur_mpsv->data.d.hi)) {
-          cur_mpsv->data.d.hi++;
-        }
-        dictitem_T *const di = TV_DICT_HI2DI(cur_mpsv->data.d.hi);
-        cur_mpsv->data.d.todo--;
+    case kMPConvDict: {
+      if (!cur_mpsv->data.d.todo) {
+        (void)_mp_pop(mpstack);
+        cur_mpsv->data.d.dict->dv_copyID = cur_mpsv->saved_copyID;
+        TYPVAL_ENCODE_CONV_DICT_END(cur_mpsv->tv, *cur_mpsv->data.d.dictp);
+        continue;
+      } else if (cur_mpsv->data.d.todo
+                 != cur_mpsv->data.d.dict->dv_hashtab.ht_used) {
+        TYPVAL_ENCODE_CONV_DICT_BETWEEN_ITEMS(cur_mpsv->tv,
+                                              *cur_mpsv->data.d.dictp);
+      }
+      while (HASHITEM_EMPTY(cur_mpsv->data.d.hi)) {
         cur_mpsv->data.d.hi++;
-        TYPVAL_ENCODE_CONV_STR_STRING(NULL, &di->di_key[0],
-                                      strlen((char *)&di->di_key[0]));
-        TYPVAL_ENCODE_CONV_DICT_AFTER_KEY(cur_mpsv->tv,
-                                          *cur_mpsv->data.d.dictp);
-        tv = &di->di_tv;
-        break;
       }
-      case kMPConvList: {
-        if (cur_mpsv->data.l.li == NULL) {
-          (void)_mp_pop(mpstack);
-          tv_list_set_copyid(cur_mpsv->data.l.list, cur_mpsv->saved_copyID);
-          TYPVAL_ENCODE_CONV_LIST_END(cur_mpsv->tv);
-          continue;
-        } else if (cur_mpsv->data.l.li
-                   != tv_list_first(cur_mpsv->data.l.list)) {
-          TYPVAL_ENCODE_CONV_LIST_BETWEEN_ITEMS(cur_mpsv->tv);
-        }
-        tv = TV_LIST_ITEM_TV(cur_mpsv->data.l.li);
-        cur_mpsv->data.l.li = TV_LIST_ITEM_NEXT(cur_mpsv->data.l.list,
-                                                cur_mpsv->data.l.li);
-        break;
+      dictitem_T *const di = TV_DICT_HI2DI(cur_mpsv->data.d.hi);
+      cur_mpsv->data.d.todo--;
+      cur_mpsv->data.d.hi++;
+      TYPVAL_ENCODE_CONV_STR_STRING(NULL, &di->di_key[0],
+                                    strlen((char *)&di->di_key[0]));
+      TYPVAL_ENCODE_CONV_DICT_AFTER_KEY(cur_mpsv->tv,
+                                        *cur_mpsv->data.d.dictp);
+      tv = &di->di_tv;
+      break;
+    }
+    case kMPConvList:
+      if (cur_mpsv->data.l.li == NULL) {
+        (void)_mp_pop(mpstack);
+        tv_list_set_copyid(cur_mpsv->data.l.list, cur_mpsv->saved_copyID);
+        TYPVAL_ENCODE_CONV_LIST_END(cur_mpsv->tv);
+        continue;
+      } else if (cur_mpsv->data.l.li
+                 != tv_list_first(cur_mpsv->data.l.list)) {
+        TYPVAL_ENCODE_CONV_LIST_BETWEEN_ITEMS(cur_mpsv->tv);
       }
-      case kMPConvPairs: {
-        if (cur_mpsv->data.l.li == NULL) {
-          (void)_mp_pop(mpstack);
-          tv_list_set_copyid(cur_mpsv->data.l.list, cur_mpsv->saved_copyID);
-          TYPVAL_ENCODE_CONV_DICT_END(cur_mpsv->tv, TYPVAL_ENCODE_NODICT_VAR);
-          continue;
-        } else if (cur_mpsv->data.l.li
-                   != tv_list_first(cur_mpsv->data.l.list)) {
-          TYPVAL_ENCODE_CONV_DICT_BETWEEN_ITEMS(
-              cur_mpsv->tv, TYPVAL_ENCODE_NODICT_VAR);
-        }
-        const list_T *const kv_pair = (
-            TV_LIST_ITEM_TV(cur_mpsv->data.l.li)->vval.v_list);
-        TYPVAL_ENCODE_SPECIAL_DICT_KEY_CHECK(
-            encode_vim_to__error_ret, *TV_LIST_ITEM_TV(tv_list_first(kv_pair)));
-        if (
-            _TYPVAL_ENCODE_CONVERT_ONE_VALUE(
-                TYPVAL_ENCODE_FIRST_ARG_NAME, &mpstack, cur_mpsv,
-                TV_LIST_ITEM_TV(tv_list_first(kv_pair)), copyID, objname)
-            == FAIL) {
-          goto encode_vim_to__error_ret;
-        }
-        TYPVAL_ENCODE_CONV_DICT_AFTER_KEY(cur_mpsv->tv,
-                                          TYPVAL_ENCODE_NODICT_VAR);
-        tv = TV_LIST_ITEM_TV(tv_list_last(kv_pair));
-        cur_mpsv->data.l.li = TV_LIST_ITEM_NEXT(cur_mpsv->data.l.list,
-                                                cur_mpsv->data.l.li);
-        break;
+      tv = TV_LIST_ITEM_TV(cur_mpsv->data.l.li);
+      cur_mpsv->data.l.li = TV_LIST_ITEM_NEXT(cur_mpsv->data.l.list,
+                                              cur_mpsv->data.l.li);
+      break;
+    case kMPConvPairs: {
+      if (cur_mpsv->data.l.li == NULL) {
+        (void)_mp_pop(mpstack);
+        tv_list_set_copyid(cur_mpsv->data.l.list, cur_mpsv->saved_copyID);
+        TYPVAL_ENCODE_CONV_DICT_END(cur_mpsv->tv, TYPVAL_ENCODE_NODICT_VAR);
+        continue;
+      } else if (cur_mpsv->data.l.li
+                 != tv_list_first(cur_mpsv->data.l.list)) {
+        TYPVAL_ENCODE_CONV_DICT_BETWEEN_ITEMS(cur_mpsv->tv, TYPVAL_ENCODE_NODICT_VAR);
       }
-      case kMPConvPartial: {
-        partial_T *const pt = cur_mpsv->data.p.pt;
-        tv = cur_mpsv->tv;
-        (void)tv;
-        switch (cur_mpsv->data.p.stage) {
-          case kMPConvPartialArgs: {
-            TYPVAL_ENCODE_CONV_FUNC_BEFORE_ARGS(tv,
-                                                pt == NULL ? 0 : pt->pt_argc);
-            cur_mpsv->data.p.stage = kMPConvPartialSelf;
-            if (pt != NULL && pt->pt_argc > 0) {
-              TYPVAL_ENCODE_CONV_LIST_START(NULL, pt->pt_argc);
-              _mp_push(mpstack, ((MPConvStackVal) {
-                .type = kMPConvPartialList,
-                .tv = NULL,
-                .saved_copyID = copyID - 1,
-                .data = {
-                  .a = {
-                    .arg = pt->pt_argv,
-                    .argv = pt->pt_argv,
-                    .todo = (size_t)pt->pt_argc,
-                  },
+      const list_T *const kv_pair = (
+                                     TV_LIST_ITEM_TV(cur_mpsv->data.l.li)->vval.v_list);
+      TYPVAL_ENCODE_SPECIAL_DICT_KEY_CHECK(encode_vim_to__error_ret,
+                                           *TV_LIST_ITEM_TV(tv_list_first(kv_pair)));
+      if (
+          _TYPVAL_ENCODE_CONVERT_ONE_VALUE(TYPVAL_ENCODE_FIRST_ARG_NAME, &mpstack, cur_mpsv,
+                                           TV_LIST_ITEM_TV(tv_list_first(kv_pair)), copyID, objname)
+          == FAIL) {
+        goto encode_vim_to__error_ret;
+      }
+      TYPVAL_ENCODE_CONV_DICT_AFTER_KEY(cur_mpsv->tv,
+                                        TYPVAL_ENCODE_NODICT_VAR);
+      tv = TV_LIST_ITEM_TV(tv_list_last(kv_pair));
+      cur_mpsv->data.l.li = TV_LIST_ITEM_NEXT(cur_mpsv->data.l.list,
+                                              cur_mpsv->data.l.li);
+      break;
+    }
+    case kMPConvPartial: {
+      partial_T *const pt = cur_mpsv->data.p.pt;
+      tv = cur_mpsv->tv;
+      (void)tv;
+      switch (cur_mpsv->data.p.stage) {
+      case kMPConvPartialArgs:
+        TYPVAL_ENCODE_CONV_FUNC_BEFORE_ARGS(tv,
+                                            pt == NULL ? 0 : pt->pt_argc);
+        cur_mpsv->data.p.stage = kMPConvPartialSelf;
+        if (pt != NULL && pt->pt_argc > 0) {
+          TYPVAL_ENCODE_CONV_LIST_START(NULL, pt->pt_argc);
+          _mp_push(mpstack, ((MPConvStackVal) {
+              .type = kMPConvPartialList,
+              .tv = NULL,
+              .saved_copyID = copyID - 1,
+              .data = {
+                .a = {
+                  .arg = pt->pt_argv,
+                  .argv = pt->pt_argv,
+                  .todo = (size_t)pt->pt_argc,
                 },
-              }));
+              },
+            }));
+        }
+        break;
+      case kMPConvPartialSelf: {
+        cur_mpsv->data.p.stage = kMPConvPartialEnd;
+        dict_T *const dict = pt == NULL ? NULL : pt->pt_dict;
+        if (dict != NULL) {
+          TYPVAL_ENCODE_CONV_FUNC_BEFORE_SELF(tv, dict->dv_hashtab.ht_used);
+          if (dict->dv_hashtab.ht_used == 0) {
+            TYPVAL_ENCODE_CONV_EMPTY_DICT(NULL, pt->pt_dict);
+            continue;
+          }
+          const int saved_copyID = dict->dv_copyID;
+          const int te_csr_ret = _TYPVAL_ENCODE_CHECK_SELF_REFERENCE(TYPVAL_ENCODE_FIRST_ARG_NAME,
+                                                                     dict, &dict->dv_copyID,
+                                                                     &mpstack, copyID, kMPConvDict,
+                                                                     objname);
+          if (te_csr_ret != NOTDONE) {
+            if (te_csr_ret == FAIL) {
+              goto encode_vim_to__error_ret;
+            } else {
+              continue;
             }
-            break;
           }
-          case kMPConvPartialSelf: {
-            cur_mpsv->data.p.stage = kMPConvPartialEnd;
-            dict_T *const dict = pt == NULL ? NULL : pt->pt_dict;
-            if (dict != NULL) {
-              TYPVAL_ENCODE_CONV_FUNC_BEFORE_SELF(tv, dict->dv_hashtab.ht_used);
-              if (dict->dv_hashtab.ht_used == 0) {
-                TYPVAL_ENCODE_CONV_EMPTY_DICT(NULL, pt->pt_dict);
-                continue;
-              }
-              const int saved_copyID = dict->dv_copyID;
-              const int te_csr_ret = _TYPVAL_ENCODE_CHECK_SELF_REFERENCE(
-                  TYPVAL_ENCODE_FIRST_ARG_NAME,
-                  dict, &dict->dv_copyID, &mpstack, copyID, kMPConvDict,
-                  objname);
-              if (te_csr_ret != NOTDONE) {
-                if (te_csr_ret == FAIL) {
-                  goto encode_vim_to__error_ret;
-                } else {
-                  continue;
-                }
-              }
-              TYPVAL_ENCODE_CONV_DICT_START(NULL, pt->pt_dict,
-                                            dict->dv_hashtab.ht_used);
-              assert(saved_copyID != copyID && saved_copyID != copyID - 1);
-              _mp_push(mpstack, ((MPConvStackVal) {
+          TYPVAL_ENCODE_CONV_DICT_START(NULL, pt->pt_dict,
+                                        dict->dv_hashtab.ht_used);
+          assert(saved_copyID != copyID && saved_copyID != copyID - 1);
+          _mp_push(mpstack, ((MPConvStackVal) {
                 .type = kMPConvDict,
                 .tv = NULL,
                 .saved_copyID = saved_copyID,
@@ -818,33 +795,31 @@ typval_encode_stop_converting_one_item:
                   },
                 },
               }));
-              TYPVAL_ENCODE_CONV_REAL_DICT_AFTER_START(NULL, pt->pt_dict,
-                                                       _mp_last(mpstack));
-            } else {
-              TYPVAL_ENCODE_CONV_FUNC_BEFORE_SELF(tv, -1);
-            }
-            break;
-          }
-          case kMPConvPartialEnd: {
-            TYPVAL_ENCODE_CONV_FUNC_END(tv);
-            (void)_mp_pop(mpstack);
-            break;
-          }
+          TYPVAL_ENCODE_CONV_REAL_DICT_AFTER_START(NULL, pt->pt_dict,
+                                                   _mp_last(mpstack));
+        } else {
+          TYPVAL_ENCODE_CONV_FUNC_BEFORE_SELF(tv, -1);
         }
-        continue;
+        break;
       }
-      case kMPConvPartialList: {
-        if (!cur_mpsv->data.a.todo) {
-          (void)_mp_pop(mpstack);
-          TYPVAL_ENCODE_CONV_LIST_END(NULL);
-          continue;
-        } else if (cur_mpsv->data.a.argv != cur_mpsv->data.a.arg) {
-          TYPVAL_ENCODE_CONV_LIST_BETWEEN_ITEMS(NULL);
-        }
-        tv = cur_mpsv->data.a.arg++;
-        cur_mpsv->data.a.todo--;
+      case kMPConvPartialEnd:
+        TYPVAL_ENCODE_CONV_FUNC_END(tv);
+        (void)_mp_pop(mpstack);
         break;
       }
+      continue;
+    }
+    case kMPConvPartialList:
+      if (!cur_mpsv->data.a.todo) {
+        (void)_mp_pop(mpstack);
+        TYPVAL_ENCODE_CONV_LIST_END(NULL);
+        continue;
+      } else if (cur_mpsv->data.a.argv != cur_mpsv->data.a.arg) {
+        TYPVAL_ENCODE_CONV_LIST_BETWEEN_ITEMS(NULL);
+      }
+      tv = cur_mpsv->data.a.arg++;
+      cur_mpsv->data.a.todo--;
+      break;
     }
     assert(tv != NULL);
     if (_TYPVAL_ENCODE_CONVERT_ONE_VALUE(TYPVAL_ENCODE_FIRST_ARG_NAME, &mpstack,
diff --git a/src/nvim/eval/typval_encode.h b/src/nvim/eval/typval_encode.h
index 3475f6d8b3..d5cf431870 100644
--- a/src/nvim/eval/typval_encode.h
+++ b/src/nvim/eval/typval_encode.h
@@ -5,14 +5,14 @@
 #ifndef NVIM_EVAL_TYPVAL_ENCODE_H
 #define NVIM_EVAL_TYPVAL_ENCODE_H
 
-#include <stddef.h>
+#include <assert.h>
 #include <inttypes.h>
+#include <stddef.h>
 #include <string.h>
-#include <assert.h>
 
-#include "nvim/lib/kvec.h"
 #include "nvim/eval/typval.h"
 #include "nvim/func_attr.h"
+#include "nvim/lib/kvec.h"
 
 /// Type of the stack entry
 typedef enum {
@@ -87,7 +87,7 @@ static inline size_t tv_strlen(const typval_T *const tv)
   assert(tv->v_type == VAR_STRING);
   return (tv->vval.v_string == NULL
           ? 0
-          : strlen((char *) tv->vval.v_string));
+          : strlen((char *)tv->vval.v_string));
 }
 
 /// Code for checking whether container references itself
@@ -100,19 +100,19 @@ static inline size_t tv_strlen(const typval_T *const tv)
 /// @param  conv_type  Type of the conversion, @see MPConvStackValType.
 #define _TYPVAL_ENCODE_DO_CHECK_SELF_REFERENCE(val, copyID_attr, copyID, \
                                                conv_type) \
-    do { \
-      const int te_csr_ret = _TYPVAL_ENCODE_CHECK_SELF_REFERENCE( \
-          TYPVAL_ENCODE_FIRST_ARG_NAME, \
-          (val), &(val)->copyID_attr, mpstack, copyID, conv_type, objname); \
-      if (te_csr_ret != NOTDONE) { \
-        return te_csr_ret; \
-      } \
-    } while (0)
+  do { \
+    const int te_csr_ret = _TYPVAL_ENCODE_CHECK_SELF_REFERENCE(TYPVAL_ENCODE_FIRST_ARG_NAME, \
+                                                               (val), &(val)->copyID_attr, mpstack, \
+                                                               copyID, conv_type, objname); \
+    if (te_csr_ret != NOTDONE) { \
+      return te_csr_ret; \
+    } \
+  } while (0)
 
 #define _TYPVAL_ENCODE_FUNC_NAME_INNER_2(pref, name, suf) \
-    pref##name##suf
+  pref##name##suf
 #define _TYPVAL_ENCODE_FUNC_NAME_INNER(pref, name, suf) \
-    _TYPVAL_ENCODE_FUNC_NAME_INNER_2(pref, name, suf)
+  _TYPVAL_ENCODE_FUNC_NAME_INNER_2(pref, name, suf)
 
 /// Construct function name, possibly using macros
 ///
@@ -125,22 +125,22 @@ static inline size_t tv_strlen(const typval_T *const tv)
 ///
 /// @return Concat: pref + #TYPVAL_ENCODE_NAME + suf.
 #define _TYPVAL_ENCODE_FUNC_NAME(pref, suf) \
-    _TYPVAL_ENCODE_FUNC_NAME_INNER(pref, TYPVAL_ENCODE_NAME, suf)
+  _TYPVAL_ENCODE_FUNC_NAME_INNER(pref, TYPVAL_ENCODE_NAME, suf)
 
 /// Self reference checker function name
 #define _TYPVAL_ENCODE_CHECK_SELF_REFERENCE \
-    _TYPVAL_ENCODE_FUNC_NAME(_typval_encode_, _check_self_reference)
+  _TYPVAL_ENCODE_FUNC_NAME(_typval_encode_, _check_self_reference)
 
 /// Entry point function name
 #define _TYPVAL_ENCODE_ENCODE \
-    _TYPVAL_ENCODE_FUNC_NAME(encode_vim_to_, )
+  _TYPVAL_ENCODE_FUNC_NAME(encode_vim_to_, )
 
 /// Name of the …convert_one_value function
 #define _TYPVAL_ENCODE_CONVERT_ONE_VALUE \
-    _TYPVAL_ENCODE_FUNC_NAME(_typval_encode_, _convert_one_value)
+  _TYPVAL_ENCODE_FUNC_NAME(_typval_encode_, _convert_one_value)
 
 /// Name of the dummy const dict_T *const variable
 #define TYPVAL_ENCODE_NODICT_VAR \
-    _TYPVAL_ENCODE_FUNC_NAME(_typval_encode_, _nodict_var)
+  _TYPVAL_ENCODE_FUNC_NAME(_typval_encode_, _nodict_var)
 
 #endif  // NVIM_EVAL_TYPVAL_ENCODE_H
diff --git a/src/nvim/eval/userfunc.h b/src/nvim/eval/userfunc.h
index 3f111343d2..ed86aaad4a 100644
--- a/src/nvim/eval/userfunc.h
+++ b/src/nvim/eval/userfunc.h
@@ -8,7 +8,7 @@
 typedef struct {
   dict_T *fd_dict;  ///< Dictionary used.
   char_u *fd_newkey;  ///< New key in "dict" in allocated memory.
-  dictitem_T  *fd_di;  ///< Dictionary item used.
+  dictitem_T *fd_di;  ///< Dictionary item used.
 } funcdict_T;
 
 typedef struct funccal_entry funccal_entry_T;
diff --git a/src/nvim/event/defs.h b/src/nvim/event/defs.h
index fdd4f17d5c..cf079681d0 100644
--- a/src/nvim/event/defs.h
+++ b/src/nvim/event/defs.h
@@ -11,7 +11,7 @@ typedef struct message {
   argv_callback handler;
   void *argv[EVENT_HANDLER_MAX_ARGC];
 } Event;
-typedef void(*event_scheduler)(Event event, void *data);
+typedef void (*event_scheduler)(Event event, void *data);
 
 #define VA_EVENT_INIT(event, h, a) \
   do { \
diff --git a/src/nvim/event/loop.h b/src/nvim/event/loop.h
index f5dd23ac8b..03cf7e489a 100644
--- a/src/nvim/event/loop.h
+++ b/src/nvim/event/loop.h
@@ -2,12 +2,11 @@
 #define NVIM_EVENT_LOOP_H
 
 #include <stdint.h>
-
 #include <uv.h>
 
+#include "nvim/event/multiqueue.h"
 #include "nvim/lib/klist.h"
 #include "nvim/os/time.h"
-#include "nvim/event/multiqueue.h"
 
 typedef void * WatcherPtr;
 
@@ -65,7 +64,7 @@ typedef struct loop {
         break; \
       } else if (remaining > 0) { \
         uint64_t now = os_hrtime(); \
-        remaining -= (int) ((now - before) / 1000000); \
+        remaining -= (int)((now - before) / 1000000); \
         before = now; \
         if (remaining <= 0) { \
           break; \
diff --git a/src/nvim/event/process.h b/src/nvim/event/process.h
index 20c02e4900..2b22cd95dc 100644
--- a/src/nvim/event/process.h
+++ b/src/nvim/event/process.h
@@ -1,10 +1,10 @@
 #ifndef NVIM_EVENT_PROCESS_H
 #define NVIM_EVENT_PROCESS_H
 
+#include "nvim/eval/typval.h"
 #include "nvim/event/loop.h"
 #include "nvim/event/rstream.h"
 #include "nvim/event/wstream.h"
-#include "nvim/eval/typval.h"
 
 typedef enum {
   kProcessTypeUv,
diff --git a/src/nvim/event/rstream.h b/src/nvim/event/rstream.h
index f30ad79ee5..77418c59a2 100644
--- a/src/nvim/event/rstream.h
+++ b/src/nvim/event/rstream.h
@@ -3,7 +3,6 @@
 
 #include <stdbool.h>
 #include <stddef.h>
-
 #include <uv.h>
 
 #include "nvim/event/loop.h"
diff --git a/src/nvim/event/stream.h b/src/nvim/event/stream.h
index a5c33a66a2..02e816b4be 100644
--- a/src/nvim/event/stream.h
+++ b/src/nvim/event/stream.h
@@ -3,7 +3,6 @@
 
 #include <stdbool.h>
 #include <stddef.h>
-
 #include <uv.h>
 
 #include "nvim/event/loop.h"
@@ -18,7 +17,7 @@ typedef struct stream Stream;
 /// @param data User-defined data
 /// @param eof If the stream reached EOF.
 typedef void (*stream_read_cb)(Stream *stream, RBuffer *buf, size_t count,
-    void *data, bool eof);
+                               void *data, bool eof);
 
 /// Type of function called when the Stream has information about a write
 /// request.
diff --git a/src/nvim/event/wstream.h b/src/nvim/event/wstream.h
index 9008de0d97..d599d29913 100644
--- a/src/nvim/event/wstream.h
+++ b/src/nvim/event/wstream.h
@@ -1,9 +1,8 @@
 #ifndef NVIM_EVENT_WSTREAM_H
 #define NVIM_EVENT_WSTREAM_H
 
-#include <stdint.h>
 #include <stdbool.h>
-
+#include <stdint.h>
 #include <uv.h>
 
 #include "nvim/event/loop.h"
diff --git a/src/nvim/lua/converter.h b/src/nvim/lua/converter.h
index 43a7e06019..1c9e60e4b2 100644
--- a/src/nvim/lua/converter.h
+++ b/src/nvim/lua/converter.h
@@ -6,8 +6,8 @@
 #include <stdint.h>
 
 #include "nvim/api/private/defs.h"
-#include "nvim/func_attr.h"
 #include "nvim/eval.h"
+#include "nvim/func_attr.h"
 
 typedef struct {
   LuaRef func_ref;
diff --git a/src/nvim/lua/executor.h b/src/nvim/lua/executor.h
index ea774ac2e3..a1f66bd02b 100644
--- a/src/nvim/lua/executor.h
+++ b/src/nvim/lua/executor.h
@@ -1,13 +1,13 @@
 #ifndef NVIM_LUA_EXECUTOR_H
 #define NVIM_LUA_EXECUTOR_H
 
-#include <lua.h>
 #include <lauxlib.h>
+#include <lua.h>
 
 #include "nvim/api/private/defs.h"
-#include "nvim/func_attr.h"
 #include "nvim/eval/typval.h"
 #include "nvim/ex_cmds_defs.h"
+#include "nvim/func_attr.h"
 #include "nvim/lua/converter.h"
 
 // Generated by msgpack-gen.lua
@@ -19,12 +19,12 @@ EXTERN LuaRef nlua_empty_dict_ref INIT(= LUA_NOREF);
 EXTERN int nlua_refcount INIT(= 0);
 
 #define set_api_error(s, err) \
-    do { \
-      Error *err_ = (err); \
-      err_->type = kErrorTypeException; \
-      err_->set = true; \
-      memcpy(&err_->msg[0], s, sizeof(s)); \
-    } while (0)
+  do { \
+    Error *err_ = (err); \
+    err_->type = kErrorTypeException; \
+    err_->set = true; \
+    memcpy(&err_->msg[0], s, sizeof(s)); \
+  } while (0)
 
 #define NLUA_CLEAR_REF(x) \
   do { \
diff --git a/src/nvim/lua/treesitter.h b/src/nvim/lua/treesitter.h
index 812166f67b..b69fb9dfae 100644
--- a/src/nvim/lua/treesitter.h
+++ b/src/nvim/lua/treesitter.h
@@ -1,9 +1,9 @@
 #ifndef NVIM_LUA_TREESITTER_H
 #define NVIM_LUA_TREESITTER_H
 
+#include <lauxlib.h>
 #include <lua.h>
 #include <lualib.h>
-#include <lauxlib.h>
 
 #include "tree_sitter/api.h"
 
diff --git a/src/nvim/lua/xdiff.h b/src/nvim/lua/xdiff.h
index cae7c98e81..b172d2f922 100644
--- a/src/nvim/lua/xdiff.h
+++ b/src/nvim/lua/xdiff.h
@@ -1,9 +1,9 @@
 #ifndef NVIM_LUA_XDIFF_H
 #define NVIM_LUA_XDIFF_H
 
+#include <lauxlib.h>
 #include <lua.h>
 #include <lualib.h>
-#include <lauxlib.h>
 
 #ifdef INCLUDE_GENERATED_DECLARATIONS
 # include "lua/xdiff.h.generated.h"
diff --git a/src/nvim/msgpack_rpc/channel.h b/src/nvim/msgpack_rpc/channel.h
index 90e1c7d48b..eb0de47437 100644
--- a/src/nvim/msgpack_rpc/channel.h
+++ b/src/nvim/msgpack_rpc/channel.h
@@ -5,10 +5,10 @@
 #include <uv.h>
 
 #include "nvim/api/private/defs.h"
-#include "nvim/event/socket.h"
+#include "nvim/channel.h"
 #include "nvim/event/process.h"
+#include "nvim/event/socket.h"
 #include "nvim/vim.h"
-#include "nvim/channel.h"
 
 #define METHOD_MAXLEN 512
 
diff --git a/src/nvim/msgpack_rpc/channel_defs.h b/src/nvim/msgpack_rpc/channel_defs.h
index de328af1ce..6647779db9 100644
--- a/src/nvim/msgpack_rpc/channel_defs.h
+++ b/src/nvim/msgpack_rpc/channel_defs.h
@@ -1,13 +1,13 @@
 #ifndef NVIM_MSGPACK_RPC_CHANNEL_DEFS_H
 #define NVIM_MSGPACK_RPC_CHANNEL_DEFS_H
 
+#include <msgpack.h>
 #include <stdbool.h>
 #include <uv.h>
-#include <msgpack.h>
 
 #include "nvim/api/private/defs.h"
-#include "nvim/event/socket.h"
 #include "nvim/event/process.h"
+#include "nvim/event/socket.h"
 #include "nvim/vim.h"
 
 typedef struct Channel Channel;
diff --git a/src/nvim/msgpack_rpc/helpers.h b/src/nvim/msgpack_rpc/helpers.h
index ef3e851a6a..e5fd92374d 100644
--- a/src/nvim/msgpack_rpc/helpers.h
+++ b/src/nvim/msgpack_rpc/helpers.h
@@ -1,13 +1,12 @@
 #ifndef NVIM_MSGPACK_RPC_HELPERS_H
 #define NVIM_MSGPACK_RPC_HELPERS_H
 
-#include <stdint.h>
-#include <stdbool.h>
-
 #include <msgpack.h>
+#include <stdbool.h>
+#include <stdint.h>
 
-#include "nvim/event/wstream.h"
 #include "nvim/api/private/defs.h"
+#include "nvim/event/wstream.h"
 
 /// Value by which objects represented as EXT type are shifted
 ///
diff --git a/src/nvim/os/input.h b/src/nvim/os/input.h
index d571965408..7026781407 100644
--- a/src/nvim/os/input.h
+++ b/src/nvim/os/input.h
@@ -1,8 +1,8 @@
 #ifndef NVIM_OS_INPUT_H
 #define NVIM_OS_INPUT_H
 
-#include <stdint.h>
 #include <stdbool.h>
+#include <stdint.h>
 
 #include "nvim/api/private/defs.h"
 #include "nvim/event/multiqueue.h"
diff --git a/src/nvim/os/os.h b/src/nvim/os/os.h
index 3e89e5a94a..bff2936f8e 100644
--- a/src/nvim/os/os.h
+++ b/src/nvim/os/os.h
@@ -9,11 +9,11 @@
 #include "nvim/vim.h"
 
 #ifdef INCLUDE_GENERATED_DECLARATIONS
+# include "os/env.h.generated.h"
 # include "os/fs.h.generated.h"
 # include "os/mem.h.generated.h"
-# include "os/env.h.generated.h"
-# include "os/users.h.generated.h"
 # include "os/stdpaths.h.generated.h"
+# include "os/users.h.generated.h"
 #endif
 
 #endif  // NVIM_OS_OS_H
diff --git a/src/nvim/os/os_defs.h b/src/nvim/os/os_defs.h
index 1b7859b0d3..8049b3b80e 100644
--- a/src/nvim/os/os_defs.h
+++ b/src/nvim/os/os_defs.h
@@ -16,7 +16,7 @@
 #define BASENAMELEN (NAME_MAX - 5)
 
 // Use the system path length if it makes sense.
-# define DEFAULT_MAXPATHL 4096
+#define DEFAULT_MAXPATHL 4096
 #if defined(PATH_MAX) && (PATH_MAX > DEFAULT_MAXPATHL)
 # define MAXPATHL PATH_MAX
 #else
diff --git a/src/nvim/os/process.h b/src/nvim/os/process.h
index 1722d56bd3..faa4762cf1 100644
--- a/src/nvim/os/process.h
+++ b/src/nvim/os/process.h
@@ -2,6 +2,7 @@
 #define NVIM_OS_PROCESS_H
 
 #include <stddef.h>
+
 #include "nvim/api/private/defs.h"
 
 #ifdef INCLUDE_GENERATED_DECLARATIONS
diff --git a/src/nvim/os/time.h b/src/nvim/os/time.h
index ad4886446a..1b6c667dbb 100644
--- a/src/nvim/os/time.h
+++ b/src/nvim/os/time.h
@@ -1,8 +1,8 @@
 #ifndef NVIM_OS_TIME_H
 #define NVIM_OS_TIME_H
 
-#include <stdint.h>
 #include <stdbool.h>
+#include <stdint.h>
 #include <time.h>
 
 typedef uint64_t Timestamp;
diff --git a/src/nvim/os/unix_defs.h b/src/nvim/os/unix_defs.h
index 60a2dfa882..4ed3b51694 100644
--- a/src/nvim/os/unix_defs.h
+++ b/src/nvim/os/unix_defs.h
@@ -1,8 +1,8 @@
 #ifndef NVIM_OS_UNIX_DEFS_H
 #define NVIM_OS_UNIX_DEFS_H
 
-#include <unistd.h>
 #include <sys/param.h>
+#include <unistd.h>
 
 // POSIX.1-2008 says that NAME_MAX should be in here
 #include <limits.h>
diff --git a/src/nvim/os/win_defs.h b/src/nvim/os/win_defs.h
index 66d72de08d..efef77be7b 100644
--- a/src/nvim/os/win_defs.h
+++ b/src/nvim/os/win_defs.h
@@ -7,11 +7,14 @@
 
 // winsock2.h must be first to avoid incompatibilities
 // with winsock.h (included by windows.h)
+
+// uncrustify:off
 #include <winsock2.h>
-#include <windows.h>
-#include <sys/stat.h>
+// uncrustify:on
 #include <io.h>
 #include <stdio.h>
+#include <sys/stat.h>
+#include <windows.h>
 
 // Windows does not have S_IFLNK but libuv defines it
 // and sets the flag for us when calling uv_fs_stat.
diff --git a/src/nvim/runtime.c b/src/nvim/runtime.c
index 0e2d23e69b..c47bffd426 100644
--- a/src/nvim/runtime.c
+++ b/src/nvim/runtime.c
@@ -332,8 +332,8 @@ int do_in_path_and_pp(char_u *path, char_u *name, int flags, DoInRuntimepathCB c
   return done;
 }
 
-static void push_path(RuntimeSearchPath *search_path, Map(String, handle_T) *rtp_used,
-                      char *entry, bool after)
+static void push_path(RuntimeSearchPath *search_path, Map(String, handle_T) *rtp_used, char *entry,
+                      bool after)
 {
   handle_T h = map_get(String, handle_T)(rtp_used, cstr_as_string(entry));
   if (h == 0) {
diff --git a/src/nvim/tui/input.h b/src/nvim/tui/input.h
index ed76455189..2a8ea32a88 100644
--- a/src/nvim/tui/input.h
+++ b/src/nvim/tui/input.h
@@ -2,8 +2,8 @@
 #define NVIM_TUI_INPUT_H
 
 #include <stdbool.h>
-
 #include <termkey.h>
+
 #include "nvim/event/stream.h"
 #include "nvim/event/time.h"
 
diff --git a/src/nvim/tui/terminfo_defs.h b/src/nvim/tui/terminfo_defs.h
index 8d77dc7225..8c328496c1 100644
--- a/src/nvim/tui/terminfo_defs.h
+++ b/src/nvim/tui/terminfo_defs.h
@@ -1,6 +1,8 @@
 // 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
 
+// uncrustify:off
+
 //
 // Generated by scripts/update_terminfo.sh and ncurses 6.1.20180127
 //
@@ -2274,3 +2276,6 @@ static const int8_t xterm_256colour_terminfo[] = {
   30,2,37,0,38,0,15,0,-99,1,2,6,120,116,101,114,109,45,50,53,54,99,111,108,111,114,124,120,116,101,114,109,32,119,105,116,104,32,50,53,54,32,99,111,108,111,114,115,0,0,1,0,0,1,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,1,0,0,1,0,1,1,0,0,0,0,0,0,0,0,1,0,80,0,0,0,8,0,0,0,24,0,0,0,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,0,1,0,0,0,0,1,0,0,0,4,0,6,0,8,0,25,0,30,0,38,0,42,0,46,0,-1,-1,57,0,74,0,76,0,80,0,87,0,-1,-1,89,0,102,0,-1,-1,106,0,110,0,120,0,124,0,-1,-1,-1,-1,-128,0,-124,0,-119,0,-114,0,-1,-1,-96,0,-91,0,-86,0,-1,-1,-81,0,-76,0,-71,0,-66,0,-57,0,-53,0,-46,0,-1,-1,-28,0,-23,0,-17,0,-11,0,-1,-1,-1,-1,-1,-1,7,1,-1,-1,-1,-1,-1,-1,25,1,-1,-1,29,1,-1,-1,-1,-1,-1,-1,31,1,-1,-1,36,1,-1,-1,-1,-1,-1,-1,-1,-1,40,1,44,1,50,1,54,1,58,1,62,1,68,1,74,1,80,1,86,1,92,1,96,1,-1,-1,101,1,-1,-1,105,1,110,1,115,1,119,1,126,1,-1,-1,-123,1,-119,1,-111,1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-103,1,-94,1,-1,-1,-1,-1,-85,1,-76,1,-67,1,-58,1,-49,1,-40,1,-31,1,-22,1,-13,1,-4,1,-1,-1,-1,-1,-1,-1,5,2,9,2,14,2,19,2,39,2,48,2,-1,-1,-1,-1,66,2,69,2,80,2,83,2,85,2,88,2,-75,2,-1,-1,-72,2,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-70,2,-1,-1,-1,-1,-1,-1,-1,-1,-66,2,-1,-1,-13,2,-1,-1,-1,-1,-9,2,-3,2,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,3,3,7,3,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,11,3,-1,-1,-1,-1,18,3,-1,-1,-1,-1,-1,-1,-1,-1,25,3,32,3,39,3,-1,-1,-1,-1,46,3,-1,-1,53,3,-1,-1,-1,-1,-1,-1,60,3,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,67,3,73,3,79,3,86,3,93,3,100,3,107,3,115,3,123,3,-125,3,-117,3,-109,3,-101,3,-93,3,-85,3,-78,3,-71,3,-64,3,-57,3,-49,3,-41,3,-33,3,-25,3,-17,3,-9,3,-1,3,7,4,14,4,21,4,28,4,35,4,43,4,51,4,59,4,67,4,75,4,83,4,91,4,99,4,106,4,113,4,120,4,127,4,-121,4,-113,4,-105,4,-97,4,-89,4,-81,4,-73,4,-65,4,-58,4,-51,4,-44,4,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-39,4,-28,4,-23,4,-4,4,0,5,9,5,16,5,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,110,5,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,115,5,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,121,5,-1,-1,-1,-1,-1,-1,125,5,-68,5,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-4,5,-1,5,27,91,90,0,7,0,13,0,27,91,37,105,37,112,49,37,100,59,37,112,50,37,100,114,0,27,91,51,103,0,27,91,72,27,91,50,74,0,27,91,75,0,27,91,74,0,27,91,37,105,37,112,49,37,100,71,0,27,91,37,105,37,112,49,37,100,59,37,112,50,37,100,72,0,10,0,27,91,72,0,27,91,63,50,53,108,0,8,0,27,91,63,49,50,108,27,91,63,50,53,104,0,27,91,67,0,27,91,65,0,27,91,63,49,50,59,50,53,104,0,27,91,80,0,27,91,77,0,27,40,48,0,27,91,53,109,0,27,91,49,109,0,27,91,63,49,48,52,57,104,27,91,50,50,59,48,59,48,116,0,27,91,50,109,0,27,91,52,104,0,27,91,56,109,0,27,91,55,109,0,27,91,55,109,0,27,91,52,109,0,27,91,37,112,49,37,100,88,0,27,40,66,0,27,40,66,27,91,109,0,27,91,63,49,48,52,57,108,27,91,50,51,59,48,59,48,116,0,27,91,52,108,0,27,91,50,55,109,0,27,91,50,52,109,0,27,91,63,53,104,36,60,49,48,48,47,62,27,91,63,53,108,0,27,91,33,112,27,91,63,51,59,52,108,27,91,52,108,27,62,0,27,91,76,0,8,0,27,91,51,126,0,27,79,66,0,27,79,80,0,27,91,50,49,126,0,27,79,81,0,27,79,82,0,27,79,83,0,27,91,49,53,126,0,27,91,49,55,126,0,27,91,49,56,126,0,27,91,49,57,126,0,27,91,50,48,126,0,27,79,72,0,27,91,50,126,0,27,79,68,0,27,91,54,126,0,27,91,53,126,0,27,79,67,0,27,91,49,59,50,66,0,27,91,49,59,50,65,0,27,79,65,0,27,91,63,49,108,27,62,0,27,91,63,49,104,27,61,0,27,91,63,49,48,51,52,108,0,27,91,63,49,48,51,52,104,0,27,91,37,112,49,37,100,80,0,27,91,37,112,49,37,100,77,0,27,91,37,112,49,37,100,66,0,27,91,37,112,49,37,100,64,0,27,91,37,112,49,37,100,83,0,27,91,37,112,49,37,100,76,0,27,91,37,112,49,37,100,68,0,27,91,37,112,49,37,100,67,0,27,91,37,112,49,37,100,84,0,27,91,37,112,49,37,100,65,0,27,91,105,0,27,91,52,105,0,27,91,53,105,0,37,112,49,37,99,27,91,37,112,50,37,123,49,125,37,45,37,100,98,0,27,99,27,93,49,48,52,7,0,27,91,33,112,27,91,63,51,59,52,108,27,91,52,108,27,62,0,27,56,0,27,91,37,105,37,112,49,37,100,100,0,27,55,0,10,0,27,77,0,37,63,37,112,57,37,116,27,40,48,37,101,27,40,66,37,59,27,91,48,37,63,37,112,54,37,116,59,49,37,59,37,63,37,112,53,37,116,59,50,37,59,37,63,37,112,50,37,116,59,52,37,59,37,63,37,112,49,37,112,51,37,124,37,116,59,55,37,59,37,63,37,112,52,37,116,59,53,37,59,37,63,37,112,55,37,116,59,56,37,59,109,0,27,72,0,9,0,27,79,69,0,96,96,97,97,102,102,103,103,105,105,106,106,107,107,108,108,109,109,110,110,111,111,112,112,113,113,114,114,115,115,116,116,117,117,118,118,119,119,120,120,121,121,122,122,123,123,124,124,125,125,126,126,0,27,91,90,0,27,91,63,55,104,0,27,91,63,55,108,0,27,79,70,0,27,79,77,0,27,91,51,59,50,126,0,27,91,49,59,50,70,0,27,91,49,59,50,72,0,27,91,50,59,50,126,0,27,91,49,59,50,68,0,27,91,54,59,50,126,0,27,91,53,59,50,126,0,27,91,49,59,50,67,0,27,91,50,51,126,0,27,91,50,52,126,0,27,91,49,59,50,80,0,27,91,49,59,50,81,0,27,91,49,59,50,82,0,27,91,49,59,50,83,0,27,91,49,53,59,50,126,0,27,91,49,55,59,50,126,0,27,91,49,56,59,50,126,0,27,91,49,57,59,50,126,0,27,91,50,48,59,50,126,0,27,91,50,49,59,50,126,0,27,91,50,51,59,50,126,0,27,91,50,52,59,50,126,0,27,91,49,59,53,80,0,27,91,49,59,53,81,0,27,91,49,59,53,82,0,27,91,49,59,53,83,0,27,91,49,53,59,53,126,0,27,91,49,55,59,53,126,0,27,91,49,56,59,53,126,0,27,91,49,57,59,53,126,0,27,91,50,48,59,53,126,0,27,91,50,49,59,53,126,0,27,91,50,51,59,53,126,0,27,91,50,52,59,53,126,0,27,91,49,59,54,80,0,27,91,49,59,54,81,0,27,91,49,59,54,82,0,27,91,49,59,54,83,0,27,91,49,53,59,54,126,0,27,91,49,55,59,54,126,0,27,91,49,56,59,54,126,0,27,91,49,57,59,54,126,0,27,91,50,48,59,54,126,0,27,91,50,49,59,54,126,0,27,91,50,51,59,54,126,0,27,91,50,52,59,54,126,0,27,91,49,59,51,80,0,27,91,49,59,51,81,0,27,91,49,59,51,82,0,27,91,49,59,51,83,0,27,91,49,53,59,51,126,0,27,91,49,55,59,51,126,0,27,91,49,56,59,51,126,0,27,91,49,57,59,51,126,0,27,91,50,48,59,51,126,0,27,91,50,49,59,51,126,0,27,91,50,51,59,51,126,0,27,91,50,52,59,51,126,0,27,91,49,59,52,80,0,27,91,49,59,52,81,0,27,91,49,59,52,82,0,27,91,49,75,0,27,91,37,105,37,100,59,37,100,82,0,27,91,54,110,0,27,91,63,37,91,59,48,49,50,51,52,53,54,55,56,57,93,99,0,27,91,99,0,27,91,51,57,59,52,57,109,0,27,93,49,48,52,7,0,27,93,52,59,37,112,49,37,100,59,114,103,98,58,37,112,50,37,123,50,53,53,125,37,42,37,123,49,48,48,48,125,37,47,37,50,46,50,88,47,37,112,51,37,123,50,53,53,125,37,42,37,123,49,48,48,48,125,37,47,37,50,46,50,88,47,37,112,52,37,123,50,53,53,125,37,42,37,123,49,48,48,48,125,37,47,37,50,46,50,88,27,92,0,27,91,51,109,0,27,91,50,51,109,0,27,91,60,0,27,91,37,63,37,112,49,37,123,56,125,37,60,37,116,51,37,112,49,37,100,37,101,37,112,49,37,123,49,54,125,37,60,37,116,57,37,112,49,37,123,56,125,37,45,37,100,37,101,51,56,59,53,59,37,112,49,37,100,37,59,109,0,27,91,37,63,37,112,49,37,123,56,125,37,60,37,116,52,37,112,49,37,100,37,101,37,112,49,37,123,49,54,125,37,60,37,116,49,48,37,112,49,37,123,56,125,37,45,37,100,37,101,52,56,59,53,59,37,112,49,37,100,37,59,109,0,27,108,0,27,109,0,3,0,1,0,73,0,-106,0,115,3,1,0,1,0,-1,-1,-1,-1,0,0,7,0,-1,-1,19,0,24,0,-1,-1,42,0,48,0,-1,-1,58,0,-1,-1,-1,-1,90,0,97,0,104,0,111,0,118,0,125,0,-124,0,-117,0,-110,0,-103,0,-96,0,-89,0,-82,0,-75,0,-68,0,-61,0,-1,-1,-54,0,-47,0,-40,0,-33,0,-26,0,-1,-1,-19,0,-12,0,-5,0,2,1,9,1,16,1,23,1,30,1,37,1,44,1,51,1,58,1,65,1,72,1,79,1,86,1,93,1,100,1,107,1,114,1,121,1,-128,1,-121,1,-114,1,-107,1,-100,1,-93,1,-86,1,-79,1,-72,1,-65,1,-1,-1,-1,-1,-1,-1,-1,-1,-58,1,-52,1,-47,1,0,0,3,0,6,0,9,0,12,0,15,0,18,0,21,0,24,0,27,0,30,0,33,0,36,0,39,0,42,0,48,0,54,0,59,0,64,0,69,0,74,0,79,0,83,0,88,0,93,0,98,0,103,0,108,0,114,0,120,0,126,0,-124,0,-118,0,-112,0,-106,0,-100,0,-94,0,-88,0,-82,0,-76,0,-71,0,-66,0,-61,0,-56,0,-51,0,-45,0,-39,0,-33,0,-27,0,-21,0,-15,0,-9,0,-3,0,3,1,9,1,15,1,21,1,27,1,33,1,39,1,45,1,51,1,57,1,63,1,69,1,73,1,78,1,83,1,88,1,93,1,98,1,102,1,106,1,110,1,114,1,119,1,124,1,27,93,49,49,50,7,0,27,93,49,50,59,37,112,49,37,115,7,0,27,91,51,74,0,27,93,53,50,59,37,112,49,37,115,59,37,112,50,37,115,7,0,27,91,50,32,113,0,27,91,37,112,49,37,100,32,113,0,27,91,63,49,48,48,54,59,49,48,48,48,37,63,37,112,49,37,123,49,125,37,61,37,116,104,37,101,108,37,59,0,27,91,51,59,51,126,0,27,91,51,59,52,126,0,27,91,51,59,53,126,0,27,91,51,59,54,126,0,27,91,51,59,55,126,0,27,91,49,59,50,66,0,27,91,49,59,51,66,0,27,91,49,59,52,66,0,27,91,49,59,53,66,0,27,91,49,59,54,66,0,27,91,49,59,55,66,0,27,91,49,59,51,70,0,27,91,49,59,52,70,0,27,91,49,59,53,70,0,27,91,49,59,54,70,0,27,91,49,59,55,70,0,27,91,49,59,51,72,0,27,91,49,59,52,72,0,27,91,49,59,53,72,0,27,91,49,59,54,72,0,27,91,49,59,55,72,0,27,91,50,59,51,126,0,27,91,50,59,52,126,0,27,91,50,59,53,126,0,27,91,50,59,54,126,0,27,91,50,59,55,126,0,27,91,49,59,51,68,0,27,91,49,59,52,68,0,27,91,49,59,53,68,0,27,91,49,59,54,68,0,27,91,49,59,55,68,0,27,91,54,59,51,126,0,27,91,54,59,52,126,0,27,91,54,59,53,126,0,27,91,54,59,54,126,0,27,91,54,59,55,126,0,27,91,53,59,51,126,0,27,91,53,59,52,126,0,27,91,53,59,53,126,0,27,91,53,59,54,126,0,27,91,53,59,55,126,0,27,91,49,59,51,67,0,27,91,49,59,52,67,0,27,91,49,59,53,67,0,27,91,49,59,54,67,0,27,91,49,59,55,67,0,27,91,49,59,50,65,0,27,91,49,59,51,65,0,27,91,49,59,52,65,0,27,91,49,59,53,65,0,27,91,49,59,54,65,0,27,91,49,59,55,65,0,27,91,50,57,109,0,27,91,57,109,0,27,91,60,37,112,49,37,100,59,37,112,50,37,100,59,37,112,51,37,100,59,37,63,37,112,52,37,116,77,37,101,109,37,59,0,65,88,0,71,48,0,88,84,0,85,56,0,67,114,0,67,115,0,69,48,0,69,51,0,77,115,0,83,48,0,83,101,0,83,115,0,84,83,0,88,77,0,103,114,98,111,109,0,103,115,98,111,109,0,107,68,67,51,0,107,68,67,52,0,107,68,67,53,0,107,68,67,54,0,107,68,67,55,0,107,68,78,0,107,68,78,51,0,107,68,78,52,0,107,68,78,53,0,107,68,78,54,0,107,68,78,55,0,107,69,78,68,51,0,107,69,78,68,52,0,107,69,78,68,53,0,107,69,78,68,54,0,107,69,78,68,55,0,107,69,78,68,56,0,107,72,79,77,51,0,107,72,79,77,52,0,107,72,79,77,53,0,107,72,79,77,54,0,107,72,79,77,55,0,107,72,79,77,56,0,107,73,67,51,0,107,73,67,52,0,107,73,67,53,0,107,73,67,54,0,107,73,67,55,0,107,76,70,84,51,0,107,76,70,84,52,0,107,76,70,84,53,0,107,76,70,84,54,0,107,76,70,84,55,0,107,78,88,84,51,0,107,78,88,84,52,0,107,78,88,84,53,0,107,78,88,84,54,0,107,78,88,84,55,0,107,80,82,86,51,0,107,80,82,86,52,0,107,80,82,86,53,0,107,80,82,86,54,0,107,80,82,86,55,0,107,82,73,84,51,0,107,82,73,84,52,0,107,82,73,84,53,0,107,82,73,84,54,0,107,82,73,84,55,0,107,85,80,0,107,85,80,51,0,107,85,80,52,0,107,85,80,53,0,107,85,80,54,0,107,85,80,55,0,107,97,50,0,107,98,49,0,107,98,51,0,107,99,50,0,114,109,120,120,0,115,109,120,120,0,120,109,0  // NOLINT
 };
 #endif  // NVIM_TUI_TERMINFO_DEFS_H
+
+// uncrustify:on
+
diff --git a/src/nvim/viml/parser/expressions.h b/src/nvim/viml/parser/expressions.h
index 838a742271..325df643e7 100644
--- a/src/nvim/viml/parser/expressions.h
+++ b/src/nvim/viml/parser/expressions.h
@@ -1,13 +1,13 @@
 #ifndef NVIM_VIML_PARSER_EXPRESSIONS_H
 #define NVIM_VIML_PARSER_EXPRESSIONS_H
 
+#include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
-#include <stdbool.h>
 
+#include "nvim/eval/typval.h"
 #include "nvim/types.h"
 #include "nvim/viml/parser/parser.h"
-#include "nvim/eval/typval.h"
 
 // Defines whether to ignore case:
 //    ==   kCCStrategyUseOption
@@ -80,7 +80,7 @@ typedef enum {
 } ExprAssignmentType;
 
 #define EXPR_OPT_SCOPE_LIST \
-    ((char[]){ kExprOptScopeGlobal, kExprOptScopeLocal })
+  ((char[]){ kExprOptScopeGlobal, kExprOptScopeLocal })
 
 /// All possible variable scopes
 typedef enum {
@@ -96,11 +96,11 @@ typedef enum {
 } ExprVarScope;
 
 #define EXPR_VAR_SCOPE_LIST \
-    ((char[]) { \
-        kExprVarScopeScript, kExprVarScopeGlobal, kExprVarScopeVim, \
-        kExprVarScopeBuffer, kExprVarScopeWindow, kExprVarScopeTabpage, \
-        kExprVarScopeLocal, kExprVarScopeBuffer, kExprVarScopeArguments, \
-    })
+  ((char[]) { \
+    kExprVarScopeScript, kExprVarScopeGlobal, kExprVarScopeVim, \
+    kExprVarScopeBuffer, kExprVarScopeWindow, kExprVarScopeTabpage, \
+    kExprVarScopeLocal, kExprVarScopeBuffer, kExprVarScopeArguments, \
+  })
 
 /// Lexer token
 typedef struct {
diff --git a/src/nvim/viml/parser/parser.h b/src/nvim/viml/parser/parser.h
index 7ac49709d8..b2933c3781 100644
--- a/src/nvim/viml/parser/parser.h
+++ b/src/nvim/viml/parser/parser.h
@@ -1,12 +1,12 @@
 #ifndef NVIM_VIML_PARSER_PARSER_H
 #define NVIM_VIML_PARSER_PARSER_H
 
+#include <assert.h>
 #include <stdbool.h>
 #include <stddef.h>
-#include <assert.h>
 
-#include "nvim/lib/kvec.h"
 #include "nvim/func_attr.h"
+#include "nvim/lib/kvec.h"
 #include "nvim/mbyte.h"
 #include "nvim/memory.h"
 
@@ -82,9 +82,9 @@ typedef struct {
 } ParserState;
 
 static inline void viml_parser_init(
-    ParserState *const ret_pstate,
-    const ParserLineGetter get_line, void *const cookie,
-    ParserHighlight *const colors)
+                                    ParserState *const ret_pstate,
+                                    const ParserLineGetter get_line, void *const cookie,
+                                    ParserHighlight *const colors)
   REAL_FATTR_ALWAYS_INLINE REAL_FATTR_NONNULL_ARG(1, 2);
 
 /// Initialize a new parser state instance
@@ -94,10 +94,8 @@ static inline void viml_parser_init(
 /// @param[in]  cookie  Argument for the get_line function.
 /// @param[in]  colors  Where to save highlighting. May be NULL if it is not
 ///                     needed.
-static inline void viml_parser_init(
-    ParserState *const ret_pstate,
-    const ParserLineGetter get_line, void *const cookie,
-    ParserHighlight *const colors)
+static inline void viml_parser_init(ParserState *const ret_pstate, const ParserLineGetter get_line,
+                                    void *const cookie, ParserHighlight *const colors)
 {
   *ret_pstate = (ParserState) {
     .reader = {
@@ -194,8 +192,7 @@ static inline void viml_parser_advance(ParserState *const pstate,
 ///
 /// @param  pstate  Parser state to advance.
 /// @param[in]  len  Number of bytes to advance.
-static inline void viml_parser_advance(ParserState *const pstate,
-                                       const size_t len)
+static inline void viml_parser_advance(ParserState *const pstate, const size_t len)
 {
   assert(pstate->pos.line == kv_size(pstate->reader.lines) - 1);
   const ParserLine pline = kv_last(pstate->reader.lines);
@@ -219,10 +216,8 @@ static inline void viml_parser_highlight(ParserState *const pstate,
 /// @param[in]  start  Start position of the highlight.
 /// @param[in]  len  Highlighting chunk length.
 /// @param[in]  group  Highlight group.
-static inline void viml_parser_highlight(ParserState *const pstate,
-                                         const ParserPosition start,
-                                         const size_t len,
-                                         const char *const group)
+static inline void viml_parser_highlight(ParserState *const pstate, const ParserPosition start,
+                                         const size_t len, const char *const group)
 {
   if (pstate->colors == NULL || len == 0) {
     return;
@@ -231,9 +226,9 @@ static inline void viml_parser_highlight(ParserState *const pstate,
          || kv_Z(*pstate->colors, 0).start.line < start.line
          || kv_Z(*pstate->colors, 0).end_col <= start.col);
   kvi_push(*pstate->colors, ((ParserHighlightChunk) {
-      .start = start,
-      .end_col = start.col + len,
-      .group = group,
+    .start = start,
+    .end_col = start.col + len,
+    .group = group,
   }));
 }
 
diff --git a/src/uncrustify.cfg b/src/uncrustify.cfg
index db0c50ff22..0e1e1de87f 100644
--- a/src/uncrustify.cfg
+++ b/src/uncrustify.cfg
@@ -1,4 +1,4 @@
-# Uncrustify-0.73.0-195-1f883c691
+# Uncrustify-0.73.0-199-0dfafb273
 
 #
 # General options
@@ -44,12 +44,12 @@ disable_processing_nl_cont      = false    # true/false
 # file.
 #
 # Default:  *INDENT-OFF*
-disable_processing_cmt          = "uncrustify:indent-off"              # string
+disable_processing_cmt          = "uncrustify:off"       # string
 
 # Specify the marker used in comments to (re)enable processing in a file.
 #
 # Default:  *INDENT-ON*
-enable_processing_cmt           = "uncrustify:indent-on"             # string
+enable_processing_cmt           = "uncrustify:on"      # string
 
 # Enable parsing of digraphs.
 enable_digraphs                 = false    # true/false
@@ -472,9 +472,13 @@ sp_after_class_colon            = ignore   # ignore/add/remove/force/not_defined
 sp_before_class_colon           = ignore   # ignore/add/remove/force/not_defined
 
 # Add or remove space after class constructor ':'.
+#
+# Default: add
 sp_after_constr_colon           = ignore   # ignore/add/remove/force/not_defined
 
 # Add or remove space before class constructor ':'.
+#
+# Default: add
 sp_before_constr_colon          = ignore   # ignore/add/remove/force/not_defined
 
 # Add or remove space before case ':'.
@@ -1103,11 +1107,16 @@ indent_class_on_colon           = false    # true/false
 # Whether to indent the stuff after a leading class initializer colon.
 indent_constr_colon             = false    # true/false
 
-# Virtual indent from the ':' for member initializers.
+# Virtual indent from the ':' for leading member initializers.
 #
 # Default: 2
 indent_ctor_init_leading        = 2        # unsigned number
 
+# Virtual indent from the ':' for following member initializers.
+#
+# Default: 2
+indent_ctor_init_following      = 2        # unsigned number
+
 # Additional indent for constructor initializer list.
 # Negative values decrease indent down to the first column.
 indent_ctor_init                = 0        # number
@@ -3298,5 +3307,5 @@ set QUESTION                     REAL_FATTR_CONST
 set QUESTION                     REAL_FATTR_NONNULL_ALL
 set QUESTION                     REAL_FATTR_PURE
 set QUESTION                     REAL_FATTR_WARN_UNUSED_RESULT
-# option(s) with 'not default' value: 62
+# option(s) with 'not default' value: 64
 #