refactor: format #15702

8 files changed, 704 insertions, 807 deletions

diff --git a/src/nvim/api/buffer.c b/src/nvim/api/buffer.c
index 3808f601d9..8973f8fef6 100644
--- a/src/nvim/api/buffer.c
+++ b/src/nvim/api/buffer.c
@@ -3,40 +3,39 @@
 
 // Some of this code was adapted from 'if_py_both.h' from the original
 // vim source
+#include <lauxlib.h>
+#include <limits.h>
 #include <stdbool.h>
 #include <stdint.h>
 #include <stdlib.h>
-#include <limits.h>
-
-#include <lauxlib.h>
 
 #include "nvim/api/buffer.h"
-#include "nvim/api/private/helpers.h"
 #include "nvim/api/private/defs.h"
-#include "nvim/lua/executor.h"
-#include "nvim/vim.h"
+#include "nvim/api/private/helpers.h"
 #include "nvim/buffer.h"
+#include "nvim/buffer_updates.h"
 #include "nvim/change.h"
 #include "nvim/charset.h"
 #include "nvim/cursor.h"
+#include "nvim/decoration.h"
+#include "nvim/ex_cmds.h"
+#include "nvim/ex_docmd.h"
+#include "nvim/extmark.h"
+#include "nvim/fileio.h"
 #include "nvim/getchar.h"
+#include "nvim/lua/executor.h"
+#include "nvim/map.h"
+#include "nvim/map_defs.h"
+#include "nvim/mark.h"
 #include "nvim/memline.h"
 #include "nvim/memory.h"
 #include "nvim/misc1.h"
-#include "nvim/ex_cmds.h"
-#include "nvim/map_defs.h"
-#include "nvim/map.h"
-#include "nvim/mark.h"
-#include "nvim/ops.h"
-#include "nvim/extmark.h"
-#include "nvim/decoration.h"
-#include "nvim/fileio.h"
 #include "nvim/move.h"
+#include "nvim/ops.h"
 #include "nvim/syntax.h"
-#include "nvim/window.h"
 #include "nvim/undo.h"
-#include "nvim/ex_docmd.h"
-#include "nvim/buffer_updates.h"
+#include "nvim/vim.h"
+#include "nvim/window.h"
 
 #ifdef INCLUDE_GENERATED_DECLARATIONS
 # include "api/buffer.c.generated.h"
@@ -149,11 +148,8 @@ Integer nvim_buf_line_count(Buffer buffer, Error *err)
 /// @param[out] err Error details, if any
 /// @return False if attach failed (invalid parameter, or buffer isn't loaded);
 ///         otherwise True. TODO: LUA_API_NO_EVAL
-Boolean nvim_buf_attach(uint64_t channel_id,
-                        Buffer buffer,
-                        Boolean send_buffer,
-                        DictionaryOf(LuaRef) opts,
-                        Error *err)
+Boolean nvim_buf_attach(uint64_t channel_id, Buffer buffer, Boolean send_buffer,
+                        DictionaryOf(LuaRef) opts, Error *err)
   FUNC_API_SINCE(4)
 {
   buf_T *buf = find_buffer_by_handle(buffer, err);
@@ -237,9 +233,7 @@ error:
 /// @param[out] err Error details, if any
 /// @return False if detach failed (because the buffer isn't loaded);
 ///         otherwise True.
-Boolean nvim_buf_detach(uint64_t channel_id,
-                        Buffer buffer,
-                        Error *err)
+Boolean nvim_buf_detach(uint64_t channel_id, Buffer buffer, Error *err)
   FUNC_API_SINCE(4) FUNC_API_REMOTE_ONLY
 {
   buf_T *buf = find_buffer_by_handle(buffer, err);
@@ -252,8 +246,7 @@ Boolean nvim_buf_detach(uint64_t channel_id,
   return true;
 }
 
-void nvim__buf_redraw_range(Buffer buffer, Integer first, Integer last,
-                            Error *err)
+void nvim__buf_redraw_range(Buffer buffer, Integer first, Integer last, Error *err)
   FUNC_API_LUA_ONLY
 {
   buf_T *buf = find_buffer_by_handle(buffer, err);
@@ -376,13 +369,8 @@ static bool check_string_array(Array arr, bool disallow_nl, Error *err)
 /// @param strict_indexing  Whether out-of-bounds should be an error.
 /// @param replacement      Array of lines to use as replacement
 /// @param[out] err         Error details, if any
-void nvim_buf_set_lines(uint64_t channel_id,
-                        Buffer buffer,
-                        Integer start,
-                        Integer end,
-                        Boolean strict_indexing,
-                        ArrayOf(String) replacement,
-                        Error *err)
+void nvim_buf_set_lines(uint64_t channel_id, Buffer buffer, Integer start, Integer end,
+                        Boolean strict_indexing, ArrayOf(String) replacement, Error *err)
   FUNC_API_SINCE(1)
   FUNC_API_CHECK_TEXTLOCK
 {
@@ -554,10 +542,8 @@ end:
 /// @param end_column       Last column
 /// @param replacement      Array of lines to use as replacement
 /// @param[out] err         Error details, if any
-void nvim_buf_set_text(uint64_t channel_id, Buffer buffer,
-                       Integer start_row, Integer start_col,
-                       Integer end_row, Integer end_col,
-                       ArrayOf(String) replacement, Error *err)
+void nvim_buf_set_text(uint64_t channel_id, Buffer buffer, Integer start_row, Integer start_col,
+                       Integer end_row, Integer end_col, ArrayOf(String) replacement, Error *err)
   FUNC_API_SINCE(7)
 {
   FIXED_TEMP_ARRAY(scratch, 1);
@@ -617,17 +603,17 @@ void nvim_buf_set_text(uint64_t channel_id, Buffer buffer,
 
   // calculate byte size of old region before it gets modified/deleted
   if (start_row == end_row) {
-      old_byte = (bcount_t)end_col - start_col;
+    old_byte = (bcount_t)end_col - start_col;
   } else {
-      const char *bufline;
-      old_byte += (bcount_t)strlen(str_at_start) - start_col;
-      for (int64_t i = 1; i < end_row - start_row; i++) {
-          int64_t lnum = start_row + i;
+    const char *bufline;
+    old_byte += (bcount_t)strlen(str_at_start) - start_col;
+    for (int64_t i = 1; i < end_row - start_row; i++) {
+      int64_t lnum = start_row + i;
 
-          bufline = (char *)ml_get_buf(buf, lnum, false);
-          old_byte += (bcount_t)(strlen(bufline))+1;
-      }
-      old_byte += (bcount_t)end_col+1;
+      bufline = (char *)ml_get_buf(buf, lnum, false);
+      old_byte += (bcount_t)(strlen(bufline))+1;
+    }
+    old_byte += (bcount_t)end_col+1;
   }
 
   String first_item = replacement.items[0].data.string;
@@ -824,7 +810,7 @@ Object nvim_buf_get_var(Buffer buffer, String name, Error *err)
   buf_T *buf = find_buffer_by_handle(buffer, err);
 
   if (!buf) {
-    return (Object) OBJECT_INIT;
+    return (Object)OBJECT_INIT;
   }
 
   return dict_get_value(buf->b_vars, name, err);
@@ -872,8 +858,8 @@ ArrayOf(Dictionary) nvim_buf_get_keymap(Buffer buffer, String mode, Error *err)
 /// @see |nvim_set_keymap()|
 ///
 /// @param  buffer  Buffer handle, or 0 for current buffer
-void nvim_buf_set_keymap(Buffer buffer, String mode, String lhs, String rhs,
-                         Dictionary opts, Error *err)
+void nvim_buf_set_keymap(Buffer buffer, String mode, String lhs, String rhs, Dictionary opts,
+                         Error *err)
   FUNC_API_SINCE(6)
 {
   modify_keymap(buffer, false, mode, lhs, rhs, opts, err);
@@ -980,7 +966,7 @@ Object nvim_buf_get_option(Buffer buffer, String name, Error *err)
   buf_T *buf = find_buffer_by_handle(buffer, err);
 
   if (!buf) {
-    return (Object) OBJECT_INIT;
+    return (Object)OBJECT_INIT;
   }
 
   return get_option_from(buf, SREQ_BUF, name, err);
@@ -994,8 +980,7 @@ Object nvim_buf_get_option(Buffer buffer, String name, Error *err)
 /// @param name       Option name
 /// @param value      Option value
 /// @param[out] err   Error details, if any
-void nvim_buf_set_option(uint64_t channel_id, Buffer buffer,
-                         String name, Object value, Error *err)
+void nvim_buf_set_option(uint64_t channel_id, Buffer buffer, String name, Object value, Error *err)
   FUNC_API_SINCE(1)
 {
   buf_T *buf = find_buffer_by_handle(buffer, err);
@@ -1044,7 +1029,7 @@ void nvim_buf_set_name(Buffer buffer, String name, Error *err)
   // Using aucmd_*: autocommands will be executed by rename_buffer
   aco_save_T aco;
   aucmd_prepbuf(&aco, buf);
-  int ren_ret = rename_buffer((char_u *) name.data);
+  int ren_ret = rename_buffer((char_u *)name.data);
   aucmd_restbuf(&aco);
 
   if (try_end(err)) {
@@ -1105,12 +1090,11 @@ void nvim_buf_delete(Buffer buffer, Dictionary opts, Error *err)
     return;
   }
 
-  int result = do_buffer(
-      unload ? DOBUF_UNLOAD : DOBUF_WIPE,
-      DOBUF_FIRST,
-      FORWARD,
-      buf->handle,
-      force);
+  int result = do_buffer(unload ? DOBUF_UNLOAD : DOBUF_WIPE,
+                         DOBUF_FIRST,
+                         FORWARD,
+                         buf->handle,
+                         force);
 
   if (result == FAIL) {
     api_set_error(err, kErrorTypeException, "Failed to unload buffer.");
@@ -1213,8 +1197,7 @@ static Array extmark_to_array(ExtmarkInfo extmark, bool id, bool add_dict)
           ADD(chunk, STRING_OBJ(cstr_to_string(vtc->text)));
           if (vtc->hl_id > 0) {
             ADD(chunk,
-                STRING_OBJ(cstr_to_string(
-                    (const char *)syn_id2name(vtc->hl_id))));
+                STRING_OBJ(cstr_to_string((const char *)syn_id2name(vtc->hl_id))));
           }
           ADD(chunks, ARRAY_OBJ(chunk));
         }
@@ -1330,9 +1313,8 @@ ArrayOf(Integer) nvim_buf_get_extmark_by_id(Buffer buffer, Integer ns_id,
 ///          - details Whether to include the details dict
 /// @param[out] err   Error details, if any
 /// @return List of [extmark_id, row, col] tuples in "traversal order".
-Array nvim_buf_get_extmarks(Buffer buffer, Integer ns_id,
-                            Object start, Object end,
-                            Dictionary opts, Error *err)
+Array nvim_buf_get_extmarks(Buffer buffer, Integer ns_id, Object start, Object end, Dictionary opts,
+                            Error *err)
   FUNC_API_SINCE(7)
 {
   Array rv = ARRAY_DICT_INIT;
@@ -1480,8 +1462,7 @@ Array nvim_buf_get_extmarks(Buffer buffer, Integer ns_id,
 ///                   example treesitter highlighting uses a value of 100.
 /// @param[out]  err   Error details, if any
 /// @return Id of the created/updated extmark
-Integer nvim_buf_set_extmark(Buffer buffer, Integer ns_id,
-                             Integer line, Integer col,
+Integer nvim_buf_set_extmark(Buffer buffer, Integer ns_id, Integer line, Integer col,
                              Dictionary opts, Error *err)
   FUNC_API_SINCE(7)
 {
@@ -1546,19 +1527,18 @@ Integer nvim_buf_set_extmark(Buffer buffer, Integer ns_id,
     } else if (strequal("hl_group", k.data)) {
       String hl_group;
       switch (v->type) {
-        case kObjectTypeString:
-          hl_group = v->data.string;
-          decor.hl_id = syn_check_group(
-              (char_u *)(hl_group.data),
-              (int)hl_group.size);
-          break;
-        case kObjectTypeInteger:
-          decor.hl_id = (int)v->data.integer;
-          break;
-        default:
-          api_set_error(err, kErrorTypeValidation,
-                        "hl_group is not valid.");
-          goto error;
+      case kObjectTypeString:
+        hl_group = v->data.string;
+        decor.hl_id = syn_check_group((char_u *)(hl_group.data),
+                                      (int)hl_group.size);
+        break;
+      case kObjectTypeInteger:
+        decor.hl_id = (int)v->data.integer;
+        break;
+      default:
+        api_set_error(err, kErrorTypeValidation,
+                      "hl_group is not valid.");
+        goto error;
       }
     } else if (strequal("virt_text", k.data)) {
       if (v->type != kObjectTypeArray) {
@@ -1692,8 +1672,7 @@ Integer nvim_buf_set_extmark(Buffer buffer, Integer ns_id,
 
   if (col2 >= 0) {
     if (line2 >= 0 && line2 < buf->b_ml.ml_line_count) {
-      len = ephemeral ? MAXCOL : STRLEN(
-          ml_get_buf(buf, (linenr_T)line2 + 1, false));
+      len = ephemeral ? MAXCOL : STRLEN(ml_get_buf(buf, (linenr_T)line2 + 1, false));
     } else if (line2 == buf->b_ml.ml_line_count) {
       // We are trying to add an extmark past final newline
       len = 0;
@@ -1713,7 +1692,7 @@ Integer nvim_buf_set_extmark(Buffer buffer, Integer ns_id,
     decor.col = 0;
     for (size_t i = 0; i < kv_size(decor.virt_text); i++) {
       decor.col
-          += (int)mb_string2cells((char_u *)kv_A(decor.virt_text, i).text);
+        += (int)mb_string2cells((char_u *)kv_A(decor.virt_text, i).text);
     }
   }
 
@@ -1761,10 +1740,7 @@ error:
 /// @param id Extmark id
 /// @param[out] err   Error details, if any
 /// @return true if the extmark was found, else false
-Boolean nvim_buf_del_extmark(Buffer buffer,
-                             Integer ns_id,
-                             Integer id,
-                             Error *err)
+Boolean nvim_buf_del_extmark(Buffer buffer, Integer ns_id, Integer id, Error *err)
   FUNC_API_SINCE(7)
 {
   buf_T *buf = find_buffer_by_handle(buffer, err);
@@ -1810,13 +1786,8 @@ Boolean nvim_buf_del_extmark(Buffer buffer,
 ///                   or -1 to highlight to end of line
 /// @param[out] err   Error details, if any
 /// @return The ns_id that was used
-Integer nvim_buf_add_highlight(Buffer buffer,
-                               Integer ns_id,
-                               String hl_group,
-                               Integer line,
-                               Integer col_start,
-                               Integer col_end,
-                               Error *err)
+Integer nvim_buf_add_highlight(Buffer buffer, Integer ns_id, String hl_group, Integer line,
+                               Integer col_start, Integer col_end, Error *err)
   FUNC_API_SINCE(1)
 {
   buf_T *buf = find_buffer_by_handle(buffer, err);
@@ -1875,10 +1846,7 @@ Integer nvim_buf_add_highlight(Buffer buffer,
 /// @param line_end   End of range of lines to clear (exclusive) or -1 to clear
 ///                   to end of buffer.
 /// @param[out] err   Error details, if any
-void nvim_buf_clear_namespace(Buffer buffer,
-                              Integer ns_id,
-                              Integer line_start,
-                              Integer line_end,
+void nvim_buf_clear_namespace(Buffer buffer, Integer ns_id, Integer line_start, Integer line_end,
                               Error *err)
   FUNC_API_SINCE(5)
 {
diff --git a/src/nvim/api/deprecated.c b/src/nvim/api/deprecated.c
index 554966e266..21b9db85c0 100644
--- a/src/nvim/api/deprecated.c
+++ b/src/nvim/api/deprecated.c
@@ -1,18 +1,18 @@
 // This is an open source non-commercial project. Dear PVS-Studio, please check
 // it. PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
 
+#include <limits.h>
 #include <stdbool.h>
 #include <stdint.h>
 #include <stdlib.h>
-#include <limits.h>
 
-#include "nvim/api/deprecated.h"
 #include "nvim/api/buffer.h"
-#include "nvim/api/vim.h"
-#include "nvim/api/private/helpers.h"
+#include "nvim/api/deprecated.h"
 #include "nvim/api/private/defs.h"
-#include "nvim/lua/executor.h"
+#include "nvim/api/private/helpers.h"
+#include "nvim/api/vim.h"
 #include "nvim/extmark.h"
+#include "nvim/lua/executor.h"
 
 #ifdef INCLUDE_GENERATED_DECLARATIONS
 # include "api/deprecated.c.generated.h"
@@ -69,10 +69,7 @@ Integer nvim_buf_get_number(Buffer buffer, Error *err)
 /// @param line_end   End of range of lines to clear (exclusive) or -1 to clear
 ///                   to end of file.
 /// @param[out] err   Error details, if any
-void nvim_buf_clear_highlight(Buffer buffer,
-                              Integer ns_id,
-                              Integer line_start,
-                              Integer line_end,
+void nvim_buf_clear_highlight(Buffer buffer, Integer ns_id, Integer line_start, Integer line_end,
                               Error *err)
   FUNC_API_SINCE(1)
   FUNC_API_DEPRECATED_SINCE(7)
@@ -111,12 +108,8 @@ void nvim_buf_clear_highlight(Buffer buffer,
 /// @param opts       Optional parameters. Currently not used.
 /// @param[out] err   Error details, if any
 /// @return The ns_id that was used
-Integer nvim_buf_set_virtual_text(Buffer buffer,
-                                  Integer src_id,
-                                  Integer line,
-                                  Array chunks,
-                                  Dictionary opts,
-                                  Error *err)
+Integer nvim_buf_set_virtual_text(Buffer buffer, Integer src_id, Integer line, Array chunks,
+                                  Dictionary opts, Error *err)
   FUNC_API_SINCE(5)
   FUNC_API_DEPRECATED_SINCE(8)
 {
@@ -171,10 +164,7 @@ Integer nvim_buf_set_virtual_text(Buffer buffer,
 ///                   the end of the buffer.
 /// @param lines      Array of lines
 /// @param[out] err   Error details, if any
-void buffer_insert(Buffer buffer,
-                   Integer lnum,
-                   ArrayOf(String) lines,
-                   Error *err)
+void buffer_insert(Buffer buffer, Integer lnum, ArrayOf(String) lines, Error *err)
 {
   // "lnum" will be the index of the line after inserting,
   // no matter if it is negative or not
@@ -268,7 +258,7 @@ ArrayOf(String) buffer_get_line_slice(Buffer buffer,
 {
   start = convert_index(start) + !include_start;
   end = convert_index(end) + include_end;
-  return nvim_buf_get_lines(0, buffer, start , end, false, err);
+  return nvim_buf_get_lines(0, buffer, start, end, false, err);
 }
 
 /// Replaces a line range on the buffer
@@ -286,13 +276,8 @@ ArrayOf(String) buffer_get_line_slice(Buffer buffer,
 /// @param replacement    Array of lines to use as replacement (0-length
 //                        array will delete the line range)
 /// @param[out] err       Error details, if any
-void buffer_set_line_slice(Buffer buffer,
-                           Integer start,
-                           Integer end,
-                           Boolean include_start,
-                           Boolean include_end,
-                           ArrayOf(String) replacement,
-                           Error *err)
+void buffer_set_line_slice(Buffer buffer, Integer start, Integer end, Boolean include_start,
+                           Boolean include_end, ArrayOf(String) replacement, Error *err)
 {
   start = convert_index(start) + !include_start;
   end = convert_index(end) + include_end;
diff --git a/src/nvim/api/private/dispatch.c b/src/nvim/api/private/dispatch.c
index 9f16da4078..38ce7ca78c 100644
--- a/src/nvim/api/private/dispatch.c
+++ b/src/nvim/api/private/dispatch.c
@@ -1,38 +1,35 @@
 // This is an open source non-commercial project. Dear PVS-Studio, please check
 // it. PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
 
-#include <inttypes.h>
-#include <stdbool.h>
 #include <assert.h>
+#include <inttypes.h>
 #include <msgpack.h>
+#include <stdbool.h>
 
-#include "nvim/map.h"
-#include "nvim/log.h"
-#include "nvim/vim.h"
-#include "nvim/msgpack_rpc/helpers.h"
+#include "nvim/api/buffer.h"
+#include "nvim/api/deprecated.h"
+#include "nvim/api/private/defs.h"
 #include "nvim/api/private/dispatch.h"
 #include "nvim/api/private/helpers.h"
-#include "nvim/api/private/defs.h"
-
-#include "nvim/api/buffer.h"
 #include "nvim/api/tabpage.h"
 #include "nvim/api/ui.h"
 #include "nvim/api/vim.h"
 #include "nvim/api/window.h"
-#include "nvim/api/deprecated.h"
+#include "nvim/log.h"
+#include "nvim/map.h"
+#include "nvim/msgpack_rpc/helpers.h"
+#include "nvim/vim.h"
 
 static Map(String, MsgpackRpcRequestHandler) methods = MAP_INIT;
 
-static void msgpack_rpc_add_method_handler(String method,
-                                           MsgpackRpcRequestHandler handler)
+static void msgpack_rpc_add_method_handler(String method, MsgpackRpcRequestHandler handler)
 {
   map_put(String, MsgpackRpcRequestHandler)(&methods, method, handler);
 }
 
 /// @param name API method name
 /// @param name_len name size (includes terminating NUL)
-MsgpackRpcRequestHandler msgpack_rpc_get_handler_for(const char *name,
-                                                     size_t name_len,
+MsgpackRpcRequestHandler msgpack_rpc_get_handler_for(const char *name, size_t name_len,
                                                      Error *error)
 {
   String m = { .data = (char *)name, .size = name_len };
diff --git a/src/nvim/api/private/helpers.c b/src/nvim/api/private/helpers.c
index ecbd4e13a3..541793e528 100644
--- a/src/nvim/api/private/helpers.c
+++ b/src/nvim/api/private/helpers.c
@@ -7,33 +7,33 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include "nvim/api/private/helpers.h"
 #include "nvim/api/private/defs.h"
+#include "nvim/api/private/helpers.h"
 #include "nvim/api/vim.h"
-#include "nvim/msgpack_rpc/helpers.h"
-#include "nvim/lua/executor.h"
 #include "nvim/ascii.h"
 #include "nvim/assert.h"
-#include "nvim/charset.h"
-#include "nvim/syntax.h"
-#include "nvim/vim.h"
 #include "nvim/buffer.h"
-#include "nvim/window.h"
-#include "nvim/memline.h"
-#include "nvim/memory.h"
+#include "nvim/charset.h"
+#include "nvim/decoration.h"
 #include "nvim/eval.h"
 #include "nvim/eval/typval.h"
-#include "nvim/map_defs.h"
-#include "nvim/map.h"
 #include "nvim/extmark.h"
-#include "nvim/decoration.h"
+#include "nvim/fileio.h"
+#include "nvim/getchar.h"
+#include "nvim/lib/kvec.h"
+#include "nvim/lua/executor.h"
+#include "nvim/map.h"
+#include "nvim/map_defs.h"
+#include "nvim/memline.h"
+#include "nvim/memory.h"
+#include "nvim/msgpack_rpc/helpers.h"
 #include "nvim/option.h"
 #include "nvim/option_defs.h"
-#include "nvim/version.h"
-#include "nvim/lib/kvec.h"
-#include "nvim/getchar.h"
-#include "nvim/fileio.h"
+#include "nvim/syntax.h"
 #include "nvim/ui.h"
+#include "nvim/version.h"
+#include "nvim/vim.h"
+#include "nvim/window.h"
 
 /// Helper structure for vim_to_object
 typedef struct {
@@ -41,8 +41,8 @@ typedef struct {
 } EncodedData;
 
 #ifdef INCLUDE_GENERATED_DECLARATIONS
-# include "api/private/helpers.c.generated.h"
 # include "api/private/funcs_metadata.generated.h"
+# include "api/private/helpers.c.generated.h"
 # include "api/private/ui_events_metadata.generated.h"
 #endif
 
@@ -210,8 +210,7 @@ dictitem_T *dict_check_writable(dict_T *dict, String key, bool del, Error *err)
 /// @param retval If true the old value will be converted and returned.
 /// @param[out] err Details of an error that may have occurred
 /// @return The old value if `retval` is true and the key was present, else NIL
-Object dict_set_var(dict_T *dict, String key, Object value, bool del,
-                    bool retval, Error *err)
+Object dict_set_var(dict_T *dict, String key, Object value, bool del, bool retval, Error *err)
 {
   Object rv = OBJECT_INIT;
   dictitem_T *di = dict_check_writable(dict, key, del, err);
@@ -326,8 +325,7 @@ Object get_option_from(void *from, int type, String name, Error *err)
 /// @param type One of `SREQ_GLOBAL`, `SREQ_WIN` or `SREQ_BUF`
 /// @param name The option name
 /// @param[out] err Details of an error that may have occurred
-void set_option_to(uint64_t channel_id, void *to, int type,
-                   String name, Object value, Error *err)
+void set_option_to(uint64_t channel_id, void *to, int type, String name, Object value, Error *err)
 {
   if (name.size == 0) {
     api_set_error(err, kErrorTypeValidation, "Empty option name");
@@ -418,61 +416,60 @@ void set_option_to(uint64_t channel_id, void *to, int type,
 #define TYPVAL_ENCODE_ALLOW_SPECIALS false
 
 #define TYPVAL_ENCODE_CONV_NIL(tv) \
-    kvi_push(edata->stack, NIL)
+  kvi_push(edata->stack, NIL)
 
 #define TYPVAL_ENCODE_CONV_BOOL(tv, num) \
-    kvi_push(edata->stack, BOOLEAN_OBJ((Boolean)(num)))
+  kvi_push(edata->stack, BOOLEAN_OBJ((Boolean)(num)))
 
 #define TYPVAL_ENCODE_CONV_NUMBER(tv, num) \
-    kvi_push(edata->stack, INTEGER_OBJ((Integer)(num)))
+  kvi_push(edata->stack, INTEGER_OBJ((Integer)(num)))
 
 #define TYPVAL_ENCODE_CONV_UNSIGNED_NUMBER TYPVAL_ENCODE_CONV_NUMBER
 
 #define TYPVAL_ENCODE_CONV_FLOAT(tv, flt) \
-    kvi_push(edata->stack, FLOAT_OBJ((Float)(flt)))
+  kvi_push(edata->stack, FLOAT_OBJ((Float)(flt)))
 
 #define TYPVAL_ENCODE_CONV_STRING(tv, str, len) \
-    do { \
-      const size_t len_ = (size_t)(len); \
-      const char *const str_ = (const char *)(str); \
-      assert(len_ == 0 || str_ != NULL); \
-      kvi_push(edata->stack, STRING_OBJ(cbuf_to_string((len_?str_:""), len_))); \
-    } while (0)
+  do { \
+    const size_t len_ = (size_t)(len); \
+    const char *const str_ = (const char *)(str); \
+    assert(len_ == 0 || str_ != NULL); \
+    kvi_push(edata->stack, STRING_OBJ(cbuf_to_string((len_?str_:""), len_))); \
+  } while (0)
 
 #define TYPVAL_ENCODE_CONV_STR_STRING TYPVAL_ENCODE_CONV_STRING
 
 #define TYPVAL_ENCODE_CONV_EXT_STRING(tv, str, len, type) \
-    TYPVAL_ENCODE_CONV_NIL(tv)
+  TYPVAL_ENCODE_CONV_NIL(tv)
 
 #define TYPVAL_ENCODE_CONV_BLOB(tv, blob, len) \
-    do { \
-      const size_t len_ = (size_t)(len); \
-      const blob_T *const blob_ = (blob); \
-      kvi_push(edata->stack, STRING_OBJ(((String) { \
-        .data = len_ != 0 ? xmemdup(blob_->bv_ga.ga_data, len_) : NULL, \
-        .size = len_ \
-      }))); \
-    } while (0)
+  do { \
+    const size_t len_ = (size_t)(len); \
+    const blob_T *const blob_ = (blob); \
+    kvi_push(edata->stack, STRING_OBJ(((String) { \
+      .data = len_ != 0 ? xmemdup(blob_->bv_ga.ga_data, len_) : NULL, \
+      .size = len_ \
+    }))); \
+  } while (0)
 
 #define TYPVAL_ENCODE_CONV_FUNC_START(tv, fun) \
-    do { \
-      TYPVAL_ENCODE_CONV_NIL(tv); \
-      goto typval_encode_stop_converting_one_item; \
-    } while (0)
+  do { \
+    TYPVAL_ENCODE_CONV_NIL(tv); \
+    goto typval_encode_stop_converting_one_item; \
+  } while (0)
 
 #define TYPVAL_ENCODE_CONV_FUNC_BEFORE_ARGS(tv, len)
 #define TYPVAL_ENCODE_CONV_FUNC_BEFORE_SELF(tv, len)
 #define TYPVAL_ENCODE_CONV_FUNC_END(tv)
 
 #define TYPVAL_ENCODE_CONV_EMPTY_LIST(tv) \
-    kvi_push(edata->stack, ARRAY_OBJ(((Array) { .capacity = 0, .size = 0 })))
+  kvi_push(edata->stack, ARRAY_OBJ(((Array) { .capacity = 0, .size = 0 })))
 
 #define TYPVAL_ENCODE_CONV_EMPTY_DICT(tv, dict) \
-    kvi_push(edata->stack, \
-             DICTIONARY_OBJ(((Dictionary) { .capacity = 0, .size = 0 })))
+  kvi_push(edata->stack, \
+           DICTIONARY_OBJ(((Dictionary) { .capacity = 0, .size = 0 })))
 
-static inline void typval_encode_list_start(EncodedData *const edata,
-                                            const size_t len)
+static inline void typval_encode_list_start(EncodedData *const edata, const size_t len)
   FUNC_ATTR_ALWAYS_INLINE FUNC_ATTR_NONNULL_ALL
 {
   kvi_push(edata->stack, ARRAY_OBJ(((Array) {
@@ -483,7 +480,7 @@ static inline void typval_encode_list_start(EncodedData *const edata,
 }
 
 #define TYPVAL_ENCODE_CONV_LIST_START(tv, len) \
-    typval_encode_list_start(edata, (size_t)(len))
+  typval_encode_list_start(edata, (size_t)(len))
 
 #define TYPVAL_ENCODE_CONV_REAL_LIST_AFTER_START(tv, mpsv)
 
@@ -498,7 +495,7 @@ static inline void typval_encode_between_list_items(EncodedData *const edata)
 }
 
 #define TYPVAL_ENCODE_CONV_LIST_BETWEEN_ITEMS(tv) \
-    typval_encode_between_list_items(edata)
+  typval_encode_between_list_items(edata)
 
 static inline void typval_encode_list_end(EncodedData *const edata)
   FUNC_ATTR_ALWAYS_INLINE FUNC_ATTR_NONNULL_ALL
@@ -511,22 +508,21 @@ static inline void typval_encode_list_end(EncodedData *const edata)
 }
 
 #define TYPVAL_ENCODE_CONV_LIST_END(tv) \
-    typval_encode_list_end(edata)
+  typval_encode_list_end(edata)
 
-static inline void typval_encode_dict_start(EncodedData *const edata,
-                                            const size_t len)
+static inline void typval_encode_dict_start(EncodedData *const edata, const size_t len)
   FUNC_ATTR_ALWAYS_INLINE FUNC_ATTR_NONNULL_ALL
 {
   kvi_push(edata->stack, DICTIONARY_OBJ(((Dictionary) {
     .capacity = len,
     .size = 0,
     .items = xmalloc(len * sizeof(
-        *((Object)OBJECT_INIT).data.dictionary.items)),
+                                  *((Object)OBJECT_INIT).data.dictionary.items)),
   })));
 }
 
 #define TYPVAL_ENCODE_CONV_DICT_START(tv, dict, len) \
-    typval_encode_dict_start(edata, (size_t)(len))
+  typval_encode_dict_start(edata, (size_t)(len))
 
 #define TYPVAL_ENCODE_CONV_REAL_DICT_AFTER_START(tv, dict, mpsv)
 
@@ -541,16 +537,16 @@ static inline void typval_encode_after_key(EncodedData *const edata)
   assert(dict->data.dictionary.size < dict->data.dictionary.capacity);
   if (key.type == kObjectTypeString) {
     dict->data.dictionary.items[dict->data.dictionary.size].key
-        = key.data.string;
+      = key.data.string;
   } else {
     api_free_object(key);
     dict->data.dictionary.items[dict->data.dictionary.size].key
-        = STATIC_CSTR_TO_STRING("__INVALID_KEY__");
+      = STATIC_CSTR_TO_STRING("__INVALID_KEY__");
   }
 }
 
 #define TYPVAL_ENCODE_CONV_DICT_AFTER_KEY(tv, dict) \
-    typval_encode_after_key(edata)
+  typval_encode_after_key(edata)
 
 static inline void typval_encode_between_dict_items(EncodedData *const edata)
   FUNC_ATTR_ALWAYS_INLINE FUNC_ATTR_NONNULL_ALL
@@ -563,7 +559,7 @@ static inline void typval_encode_between_dict_items(EncodedData *const edata)
 }
 
 #define TYPVAL_ENCODE_CONV_DICT_BETWEEN_ITEMS(tv, dict) \
-    typval_encode_between_dict_items(edata)
+  typval_encode_between_dict_items(edata)
 
 static inline void typval_encode_dict_end(EncodedData *const edata)
   FUNC_ATTR_ALWAYS_INLINE FUNC_ATTR_NONNULL_ALL
@@ -576,10 +572,10 @@ static inline void typval_encode_dict_end(EncodedData *const edata)
 }
 
 #define TYPVAL_ENCODE_CONV_DICT_END(tv, dict) \
-    typval_encode_dict_end(edata)
+  typval_encode_dict_end(edata)
 
 #define TYPVAL_ENCODE_CONV_RECURSE(val, conv_type) \
-    TYPVAL_ENCODE_CONV_NIL(val)
+  TYPVAL_ENCODE_CONV_NIL(val)
 
 #define TYPVAL_ENCODE_SCOPE static
 #define TYPVAL_ENCODE_NAME object
@@ -708,15 +704,15 @@ String cchar_to_string(char c)
 ///         empty String is returned
 String cstr_to_string(const char *str)
 {
-    if (str == NULL) {
-      return (String)STRING_INIT;
-    }
+  if (str == NULL) {
+    return (String)STRING_INIT;
+  }
 
-    size_t len = strlen(str);
-    return (String){
-      .data = xmemdupz(str, len),
-      .size = len,
-    };
+  size_t len = strlen(str);
+  return (String){
+    .data = xmemdupz(str, len),
+    .size = len,
+  };
 }
 
 /// Copies buffer to an allocated String.
@@ -817,8 +813,8 @@ Array string_to_array(const String input, bool crlf)
 /// @param  buffer    Buffer handle for a specific buffer, or 0 for the current
 ///                   buffer, or -1 to signify global behavior ("all buffers")
 /// @param  is_unmap  When true, removes the mapping that matches {lhs}.
-void modify_keymap(Buffer buffer, bool is_unmap, String mode, String lhs,
-                   String rhs, Dictionary opts, Error *err)
+void modify_keymap(Buffer buffer, bool is_unmap, String mode, String lhs, String rhs,
+                   Dictionary opts, Error *err)
 {
   char *err_msg = NULL;  // the error message to report, if any
   char *err_arg = NULL;  // argument for the error message format string
@@ -916,21 +912,21 @@ void modify_keymap(Buffer buffer, bool is_unmap, String mode, String lhs,
   }
 
   switch (buf_do_map(maptype_val, &parsed_args, mode_val, 0, target_buf)) {
-    case 0:
-      break;
-    case 1:
-      api_set_error(err, kErrorTypeException, (char *)e_invarg, 0);
-      goto fail_and_free;
-    case 2:
-      api_set_error(err, kErrorTypeException, (char *)e_nomap, 0);
-      goto fail_and_free;
-    case 5:
-      api_set_error(err, kErrorTypeException,
-                    "E227: mapping already exists for %s", parsed_args.lhs);
-      goto fail_and_free;
-    default:
-      assert(false && "Unrecognized return code!");
-      goto fail_and_free;
+  case 0:
+    break;
+  case 1:
+    api_set_error(err, kErrorTypeException, (char *)e_invarg, 0);
+    goto fail_and_free;
+  case 2:
+    api_set_error(err, kErrorTypeException, (char *)e_nomap, 0);
+    goto fail_and_free;
+  case 5:
+    api_set_error(err, kErrorTypeException,
+                  "E227: mapping already exists for %s", parsed_args.lhs);
+    goto fail_and_free;
+  default:
+    assert(false && "Unrecognized return code!");
+    goto fail_and_free;
   }  // switch
 
   xfree(lhs_buf);
@@ -986,44 +982,44 @@ Integer parse_keymap_opts(Dictionary opts, MapArguments *out, Error *err)
 
     bool was_valid_opt = false;
     switch (optname[0]) {
-      // note: strncmp up to and including the null terminator, so that
-      // "nowaitFoobar" won't match against "nowait"
-
-      // don't recognize 'buffer' as a key; user shouldn't provide <buffer>
-      // when calling nvim_set_keymap or nvim_buf_set_keymap, since it can be
-      // inferred from which function they called
-      case 'n':
-        if (STRNCMP(optname, "noremap", 8) == 0) {
-          was_valid_opt = true;
-          out->noremap = key_and_val->value.data.boolean;
-        } else if (STRNCMP(optname, "nowait", 7) == 0) {
-          was_valid_opt = true;
-          out->nowait = key_and_val->value.data.boolean;
-        }
-        break;
-      case 's':
-        if (STRNCMP(optname, "silent", 7) == 0) {
-          was_valid_opt = true;
-          out->silent = key_and_val->value.data.boolean;
-        } else if (STRNCMP(optname, "script", 7) == 0) {
-          was_valid_opt = true;
-          out->script = key_and_val->value.data.boolean;
-        }
-        break;
-      case 'e':
-        if (STRNCMP(optname, "expr", 5) == 0) {
-          was_valid_opt = true;
-          out->expr = key_and_val->value.data.boolean;
-        }
-        break;
-      case 'u':
-        if (STRNCMP(optname, "unique", 7) == 0) {
-          was_valid_opt = true;
-          out->unique = key_and_val->value.data.boolean;
-        }
-        break;
-      default:
-        break;
+    // note: strncmp up to and including the null terminator, so that
+    // "nowaitFoobar" won't match against "nowait"
+
+    // don't recognize 'buffer' as a key; user shouldn't provide <buffer>
+    // when calling nvim_set_keymap or nvim_buf_set_keymap, since it can be
+    // inferred from which function they called
+    case 'n':
+      if (STRNCMP(optname, "noremap", 8) == 0) {
+        was_valid_opt = true;
+        out->noremap = key_and_val->value.data.boolean;
+      } else if (STRNCMP(optname, "nowait", 7) == 0) {
+        was_valid_opt = true;
+        out->nowait = key_and_val->value.data.boolean;
+      }
+      break;
+    case 's':
+      if (STRNCMP(optname, "silent", 7) == 0) {
+        was_valid_opt = true;
+        out->silent = key_and_val->value.data.boolean;