refactor(api): use typed keysets

Initially this is just for geting rid of boilerplate,
but eventually the types could get exposed as metadata

20 files changed, 754 insertions, 846 deletions

diff --git a/src/nvim/api/autocmd.c b/src/nvim/api/autocmd.c
index 6ab1283f89..aa0c2695ad 100644
--- a/src/nvim/api/autocmd.c
+++ b/src/nvim/api/autocmd.c
@@ -11,6 +11,7 @@
 #include "lauxlib.h"
 #include "nvim/api/autocmd.h"
 #include "nvim/api/private/defs.h"
+#include "nvim/api/private/dispatch.h"
 #include "nvim/api/private/helpers.h"
 #include "nvim/api/private/validate.h"
 #include "nvim/ascii.h"
@@ -125,7 +126,7 @@ Array nvim_get_autocmds(Dict(get_autocmds) *opts, Error *err)
     });
   }
 
-  if (HAS_KEY(opts->event)) {
+  if (HAS_KEY(opts, get_autocmds, event)) {
     check_event = true;
 
     Object v = opts->event;
@@ -148,13 +149,13 @@ Array nvim_get_autocmds(Dict(get_autocmds) *opts, Error *err)
     }
   }
 
-  VALIDATE((!HAS_KEY(opts->pattern) || !HAS_KEY(opts->buffer)),
+  VALIDATE((!HAS_KEY(opts, get_autocmds, pattern) || !HAS_KEY(opts, get_autocmds, buffer)),
            "%s", "Cannot use both 'pattern' and 'buffer'", {
     goto cleanup;
   });
 
   int pattern_filter_count = 0;
-  if (HAS_KEY(opts->pattern)) {
+  if (HAS_KEY(opts, get_autocmds, pattern)) {
     Object v = opts->pattern;
     if (v.type == kObjectTypeString) {
       pattern_filters[pattern_filter_count] = v.data.string.data;
@@ -209,7 +210,7 @@ Array nvim_get_autocmds(Dict(get_autocmds) *opts, Error *err)
       snprintf(pattern_buflocal, BUFLOCAL_PAT_LEN, "<buffer=%d>", (int)buf->handle);
       ADD(buffers, CSTR_TO_OBJ(pattern_buflocal));
     });
-  } else if (HAS_KEY(opts->buffer)) {
+  } else if (HAS_KEY(opts, get_autocmds, buffer)) {
     VALIDATE_EXP(false, "buffer", "Integer or Array", api_typename(opts->buffer.type), {
       goto cleanup;
     });
@@ -408,12 +409,12 @@ Integer nvim_create_autocmd(uint64_t channel_id, Object event, Dict(create_autoc
     goto cleanup;
   }
 
-  VALIDATE((!HAS_KEY(opts->callback) || !HAS_KEY(opts->command)),
+  VALIDATE((!HAS_KEY(opts, create_autocmd, callback) || !HAS_KEY(opts, create_autocmd, command)),
            "%s", "Cannot use both 'callback' and 'command'", {
     goto cleanup;
   });
 
-  if (HAS_KEY(opts->callback)) {
+  if (HAS_KEY(opts, create_autocmd, callback)) {
     // NOTE: We could accept callable tables, but that isn't common in the API.
 
     Object *callback = &opts->callback;
@@ -442,36 +443,33 @@ Integer nvim_create_autocmd(uint64_t channel_id, Object event, Dict(create_autoc
 
     aucmd.type = CALLABLE_CB;
     aucmd.callable.cb = cb;
-  } else if (HAS_KEY(opts->command)) {
-    Object *command = &opts->command;
-    VALIDATE_T("command", kObjectTypeString, command->type, {
-      goto cleanup;
-    });
+  } else if (HAS_KEY(opts, create_autocmd, command)) {
     aucmd.type = CALLABLE_EX;
-    aucmd.callable.cmd = string_to_cstr(command->data.string);
+    aucmd.callable.cmd = string_to_cstr(opts->command);
   } else {
     VALIDATE(false, "%s", "Required: 'command' or 'callback'", {
       goto cleanup;
     });
   }
 
-  bool is_once = api_object_to_bool(opts->once, "once", false, err);
-  bool is_nested = api_object_to_bool(opts->nested, "nested", false, err);
-
   int au_group = get_augroup_from_object(opts->group, err);
   if (au_group == AUGROUP_ERROR) {
     goto cleanup;
   }
 
-  if (!get_patterns_from_pattern_or_buf(&patterns, opts->pattern, opts->buffer, err)) {
+  bool has_buffer = HAS_KEY(opts, create_autocmd, buffer);
+
+  VALIDATE((!HAS_KEY(opts, create_autocmd, pattern) || !has_buffer),
+           "%s", "Cannot use both 'pattern' and 'buffer' for the same autocmd", {
+    goto cleanup;
+  });
+
+  if (!get_patterns_from_pattern_or_buf(&patterns, opts->pattern, has_buffer, opts->buffer, err)) {
     goto cleanup;
   }
 
-  if (HAS_KEY(opts->desc)) {
-    VALIDATE_T("desc", kObjectTypeString, opts->desc.type, {
-      goto cleanup;
-    });
-    desc = opts->desc.data.string.data;
+  if (HAS_KEY(opts, create_autocmd, desc)) {
+    desc = opts->desc.data;
   }
 
   if (patterns.size == 0) {
@@ -496,8 +494,8 @@ Integer nvim_create_autocmd(uint64_t channel_id, Object event, Dict(create_autoc
                                   pat.data.string.data,
                                   (int)pat.data.string.size,
                                   au_group,
-                                  is_once,
-                                  is_nested,
+                                  opts->once,
+                                  opts->nested,
                                   desc,
                                   aucmd);
       });
@@ -568,7 +566,9 @@ void nvim_clear_autocmds(Dict(clear_autocmds) *opts, Error *err)
     goto cleanup;
   }
 
-  VALIDATE((!HAS_KEY(opts->pattern) || !HAS_KEY(opts->buffer)),
+  bool has_buffer = HAS_KEY(opts, clear_autocmds, buffer);
+
+  VALIDATE((!HAS_KEY(opts, clear_autocmds, pattern) || !has_buffer),
            "%s", "Cannot use both 'pattern' and 'buffer'", {
     goto cleanup;
   });
@@ -578,7 +578,7 @@ void nvim_clear_autocmds(Dict(clear_autocmds) *opts, Error *err)
     goto cleanup;
   }
 
-  if (!get_patterns_from_pattern_or_buf(&patterns, opts->pattern, opts->buffer, err)) {
+  if (!get_patterns_from_pattern_or_buf(&patterns, opts->pattern, has_buffer, opts->buffer, err)) {
     goto cleanup;
   }
 
@@ -742,21 +742,22 @@ void nvim_exec_autocmds(Object event, Dict(exec_autocmds) *opts, Error *err)
     });
   }
 
-  if (HAS_KEY(opts->buffer)) {
-    Object buf_obj = opts->buffer;
-    VALIDATE_EXP((buf_obj.type == kObjectTypeInteger || buf_obj.type == kObjectTypeBuffer),
-                 "buffer", "Integer", api_typename(buf_obj.type), {
+  bool has_buffer = false;
+  if (HAS_KEY(opts, exec_autocmds, buffer)) {
+    VALIDATE((!HAS_KEY(opts, exec_autocmds, pattern)),
+             "%s", "Cannot use both 'pattern' and 'buffer' for the same autocmd", {
       goto cleanup;
     });
 
-    buf = find_buffer_by_handle((Buffer)buf_obj.data.integer, err);
+    has_buffer = true;
+    buf = find_buffer_by_handle(opts->buffer, err);
 
     if (ERROR_SET(err)) {
       goto cleanup;
     }
   }
 
-  if (!get_patterns_from_pattern_or_buf(&patterns, opts->pattern, opts->buffer, err)) {
+  if (!get_patterns_from_pattern_or_buf(&patterns, opts->pattern, has_buffer, opts->buffer, err)) {
     goto cleanup;
   }
 
@@ -764,20 +765,19 @@ void nvim_exec_autocmds(Object event, Dict(exec_autocmds) *opts, Error *err)
     ADD(patterns, STATIC_CSTR_TO_OBJ(""));
   }
 
-  if (HAS_KEY(opts->data)) {
+  if (HAS_KEY(opts, exec_autocmds, data)) {
     data = &opts->data;
   }
 
-  modeline = api_object_to_bool(opts->modeline, "modeline", true, err);
+  modeline = GET_BOOL_OR_TRUE(opts, exec_autocmds, modeline);
 
   bool did_aucmd = false;
   FOREACH_ITEM(event_array, event_str, {
     GET_ONE_EVENT(event_nr, event_str, cleanup)
 
     FOREACH_ITEM(patterns, pat, {
-      char *fname = !HAS_KEY(opts->buffer) ? pat.data.string.data : NULL;
-      did_aucmd |=
-        apply_autocmds_group(event_nr, fname, NULL, true, au_group, buf, NULL, data);
+      char *fname = !has_buffer ? pat.data.string.data : NULL;
+      did_aucmd |= apply_autocmds_group(event_nr, fname, NULL, true, au_group, buf, NULL, data);
     })
   })
 
@@ -837,17 +837,12 @@ static int get_augroup_from_object(Object group, Error *err)
   }
 }
 
-static bool get_patterns_from_pattern_or_buf(Array *patterns, Object pattern, Object buffer,
-                                             Error *err)
+static bool get_patterns_from_pattern_or_buf(Array *patterns, Object pattern, bool has_buffer,
+                                             Buffer buffer, Error *err)
 {
   const char pattern_buflocal[BUFLOCAL_PAT_LEN];
 
-  VALIDATE((!HAS_KEY(pattern) || !HAS_KEY(buffer)),
-           "%s", "Cannot use both 'pattern' and 'buffer' for the same autocmd", {
-    return false;
-  });
-
-  if (HAS_KEY(pattern)) {
+  if (pattern.type != kObjectTypeNil) {
     Object *v = &pattern;
 
     if (v->type == kObjectTypeString) {
@@ -880,13 +875,8 @@ static bool get_patterns_from_pattern_or_buf(Array *patterns, Object pattern, Ob
         return false;
       });
     }
-  } else if (HAS_KEY(buffer)) {
-    VALIDATE_EXP((buffer.type == kObjectTypeInteger || buffer.type == kObjectTypeBuffer),
-                 "buffer", "Integer", api_typename(buffer.type), {
-      return false;
-    });
-
-    buf_T *buf = find_buffer_by_handle((Buffer)buffer.data.integer, err);
+  } else if (has_buffer) {
+    buf_T *buf = find_buffer_by_handle(buffer, err);
     if (ERROR_SET(err)) {
       return false;
     }
diff --git a/src/nvim/api/command.c b/src/nvim/api/command.c
index 75140beb88..2b09cfc4b2 100644
--- a/src/nvim/api/command.c
+++ b/src/nvim/api/command.c
@@ -341,16 +341,6 @@ String nvim_cmd(uint64_t channel_id, Dict(cmd) *cmd, Dict(cmd_opts) *opts, Error
     } \
   } while (0)
 
-#define OBJ_TO_CMOD_FLAG(flag, value, default, varname) \
-  do { \
-    if (api_object_to_bool(value, varname, default, err)) { \
-      cmdinfo.cmdmod.cmod_flags |= (flag); \
-    } \
-    if (ERROR_SET(err)) { \
-      goto end; \
-    } \
-  } while (0)
-
 #define VALIDATE_MOD(cond, mod_, name_) \
   do { \
     if (!(cond)) { \
@@ -359,18 +349,14 @@ String nvim_cmd(uint64_t channel_id, Dict(cmd) *cmd, Dict(cmd_opts) *opts, Error
     } \
   } while (0)
 
-  bool output;
-  OBJ_TO_BOOL(output, opts->output, false, "'output'");
-
-  VALIDATE_R(HAS_KEY(cmd->cmd), "cmd", {
+  VALIDATE_R(HAS_KEY(cmd, cmd, cmd), "cmd", {
     goto end;
   });
-  VALIDATE_EXP((cmd->cmd.type == kObjectTypeString && cmd->cmd.data.string.data[0] != NUL),
-               "cmd", "non-empty String", NULL, {
+  VALIDATE_EXP((cmd->cmd.data[0] != NUL), "cmd", "non-empty String", NULL, {
     goto end;
   });
 
-  cmdname = string_to_cstr(cmd->cmd.data.string);
+  cmdname = string_to_cstr(cmd->cmd);
   ea.cmd = cmdname;
 
   char *p = find_ex_command(&ea, NULL);
@@ -407,15 +393,11 @@ String nvim_cmd(uint64_t channel_id, Dict(cmd) *cmd, Dict(cmd_opts) *opts, Error
   }
 
   // Parse command arguments since it's needed to get the command address type.
-  if (HAS_KEY(cmd->args)) {
-    VALIDATE_T("args", kObjectTypeArray, cmd->args.type, {
-      goto end;
-    });
-
+  if (HAS_KEY(cmd, cmd, args)) {
     // Process all arguments. Convert non-String arguments to String and check if String arguments
     // have non-whitespace characters.
-    for (size_t i = 0; i < cmd->args.data.array.size; i++) {
-      Object elem = cmd->args.data.array.items[i];
+    for (size_t i = 0; i < cmd->args.size; i++) {
+      Object elem = cmd->args.items[i];
       char *data_str;
 
       switch (elem.type) {
@@ -477,16 +459,13 @@ String nvim_cmd(uint64_t channel_id, Dict(cmd) *cmd, Dict(cmd_opts) *opts, Error
   // since it only ever checks the first argument.
   set_cmd_addr_type(&ea, args.size > 0 ? args.items[0].data.string.data : NULL);
 
-  if (HAS_KEY(cmd->range)) {
-    VALIDATE_MOD((ea.argt & EX_RANGE), "range", cmd->cmd.data.string.data);
-    VALIDATE_T("range", kObjectTypeArray, cmd->range.type, {
-      goto end;
-    });
-    VALIDATE_EXP((cmd->range.data.array.size <= 2), "range", "<=2 elements", NULL, {
+  if (HAS_KEY(cmd, cmd, range)) {
+    VALIDATE_MOD((ea.argt & EX_RANGE), "range", cmd->cmd.data);
+    VALIDATE_EXP((cmd->range.size <= 2), "range", "<=2 elements", NULL, {
       goto end;
     });
 
-    Array range = cmd->range.data.array;
+    Array range = cmd->range;
     ea.addr_count = (int)range.size;
 
     for (size_t i = 0; i < range.size; i++) {
@@ -519,22 +498,21 @@ String nvim_cmd(uint64_t channel_id, Dict(cmd) *cmd, Dict(cmd_opts) *opts, Error
     }
   }
 
-  if (HAS_KEY(cmd->count)) {
-    VALIDATE_MOD((ea.argt & EX_COUNT), "count", cmd->cmd.data.string.data);
-    VALIDATE_EXP((cmd->count.type == kObjectTypeInteger && cmd->count.data.integer >= 0),
-                 "count", "non-negative Integer", NULL, {
+  if (HAS_KEY(cmd, cmd, count)) {
+    VALIDATE_MOD((ea.argt & EX_COUNT), "count", cmd->cmd.data);
+    VALIDATE_EXP((cmd->count >= 0), "count", "non-negative Integer", NULL, {
       goto end;
     });
-    set_cmd_count(&ea, (linenr_T)cmd->count.data.integer, true);
+    set_cmd_count(&ea, (linenr_T)cmd->count, true);
   }
 
-  if (HAS_KEY(cmd->reg)) {
-    VALIDATE_MOD((ea.argt & EX_REGSTR), "register", cmd->cmd.data.string.data);
-    VALIDATE_EXP((cmd->reg.type == kObjectTypeString && cmd->reg.data.string.size == 1),
-                 "reg", "single character", cmd->reg.data.string.data, {
+  if (HAS_KEY(cmd, cmd, reg)) {
+    VALIDATE_MOD((ea.argt & EX_REGSTR), "register", cmd->cmd.data);
+    VALIDATE_EXP((cmd->reg.size == 1),
+                 "reg", "single character", cmd->reg.data, {
       goto end;
     });
-    char regname = cmd->reg.data.string.data[0];
+    char regname = cmd->reg.data[0];
     VALIDATE((regname != '='), "%s", "Cannot use register \"=", {
       goto end;
     });
@@ -545,22 +523,17 @@ String nvim_cmd(uint64_t channel_id, Dict(cmd) *cmd, Dict(cmd_opts) *opts, Error
     ea.regname = (uint8_t)regname;
   }
 
-  OBJ_TO_BOOL(ea.forceit, cmd->bang, false, "'bang'");
-  VALIDATE_MOD((!ea.forceit || (ea.argt & EX_BANG)), "bang", cmd->cmd.data.string.data);
+  ea.forceit = cmd->bang;
+  VALIDATE_MOD((!ea.forceit || (ea.argt & EX_BANG)), "bang", cmd->cmd.data);
 
-  if (HAS_KEY(cmd->magic)) {
-    VALIDATE_T_DICT("magic", cmd->magic, {
-      goto end;
-    });
-
-    Dict(cmd_magic) magic = { 0 };
-    if (!api_dict_to_keydict(&magic, KeyDict_cmd_magic_get_field,
-                             cmd->magic.data.dictionary, err)) {
+  if (HAS_KEY(cmd, cmd, magic)) {
+    Dict(cmd_magic) magic[1] = { 0 };
+    if (!api_dict_to_keydict(magic, KeyDict_cmd_magic_get_field, cmd->magic, err)) {
       goto end;
     }
 
-    OBJ_TO_BOOL(cmdinfo.magic.file, magic.file, ea.argt & EX_XFILE, "'magic.file'");
-    OBJ_TO_BOOL(cmdinfo.magic.bar, magic.bar, ea.argt & EX_TRLBAR, "'magic.bar'");
+    cmdinfo.magic.file = HAS_KEY(magic, cmd_magic, file) ? magic->file : (ea.argt & EX_XFILE);
+    cmdinfo.magic.bar = HAS_KEY(magic, cmd_magic, bar) ? magic->bar : (ea.argt & EX_TRLBAR);
     if (cmdinfo.magic.file) {
       ea.argt |= EX_XFILE;
     } else {
@@ -571,89 +544,63 @@ String nvim_cmd(uint64_t channel_id, Dict(cmd) *cmd, Dict(cmd_opts) *opts, Error
     cmdinfo.magic.bar = ea.argt & EX_TRLBAR;
   }
 
-  if (HAS_KEY(cmd->mods)) {
-    VALIDATE_T_DICT("mods", cmd->mods, {
-      goto end;
-    });
-
-    Dict(cmd_mods) mods = { 0 };
-    if (!api_dict_to_keydict(&mods, KeyDict_cmd_mods_get_field, cmd->mods.data.dictionary, err)) {
+  if (HAS_KEY(cmd, cmd, mods)) {
+    Dict(cmd_mods) mods[1] = { 0 };
+    if (!api_dict_to_keydict(mods, KeyDict_cmd_mods_get_field, cmd->mods, err)) {
       goto end;
     }
 
-    if (HAS_KEY(mods.filter)) {
-      VALIDATE_T_DICT("mods.filter", mods.filter, {
-        goto end;
-      });
-
-      Dict(cmd_mods_filter) filter = { 0 };
+    if (HAS_KEY(mods, cmd_mods, filter)) {
+      Dict(cmd_mods_filter) filter[1] = { 0 };
 
       if (!api_dict_to_keydict(&filter, KeyDict_cmd_mods_filter_get_field,
-                               mods.filter.data.dictionary, err)) {
+                               mods->filter, err)) {
         goto end;
       }
 
-      if (HAS_KEY(filter.pattern)) {
-        VALIDATE_T2(filter.pattern, kObjectTypeString, {
-          goto end;
-        });
-
-        OBJ_TO_BOOL(cmdinfo.cmdmod.cmod_filter_force, filter.force, false, "'mods.filter.force'");
+      if (HAS_KEY(filter, cmd_mods_filter, pattern)) {
+        cmdinfo.cmdmod.cmod_filter_force = filter->force;
 
         // "filter! // is not no-op, so add a filter if either the pattern is non-empty or if filter
         // is inverted.
-        if (*filter.pattern.data.string.data != NUL || cmdinfo.cmdmod.cmod_filter_force) {
-          cmdinfo.cmdmod.cmod_filter_pat = string_to_cstr(filter.pattern.data.string);
+        if (*filter->pattern.data != NUL || cmdinfo.cmdmod.cmod_filter_force) {
+          cmdinfo.cmdmod.cmod_filter_pat = string_to_cstr(filter->pattern);
           cmdinfo.cmdmod.cmod_filter_regmatch.regprog = vim_regcomp(cmdinfo.cmdmod.cmod_filter_pat,
                                                                     RE_MAGIC);
         }
       }
     }
 
-    if (HAS_KEY(mods.tab)) {
-      VALIDATE_T2(mods.tab, kObjectTypeInteger, {
-        goto end;
-      });
-      if ((int)mods.tab.data.integer >= 0) {
+    if (HAS_KEY(mods, cmd_mods, tab)) {
+      if ((int)mods->tab >= 0) {
         // Silently ignore negative integers to allow mods.tab to be set to -1.
-        cmdinfo.cmdmod.cmod_tab = (int)mods.tab.data.integer + 1;
+        cmdinfo.cmdmod.cmod_tab = (int)mods->tab + 1;
       }
     }
 
-    if (HAS_KEY(mods.verbose)) {
-      VALIDATE_T2(mods.verbose, kObjectTypeInteger, {
-        goto end;
-      });
-      if ((int)mods.verbose.data.integer >= 0) {
+    if (HAS_KEY(mods, cmd_mods, verbose)) {
+      if ((int)mods->verbose >= 0) {
         // Silently ignore negative integers to allow mods.verbose to be set to -1.
-        cmdinfo.cmdmod.cmod_verbose = (int)mods.verbose.data.integer + 1;
+        cmdinfo.cmdmod.cmod_verbose = (int)mods->verbose + 1;
       }
     }
 
-    bool vertical;
-    OBJ_TO_BOOL(vertical, mods.vertical, false, "'mods.vertical'");
-    cmdinfo.cmdmod.cmod_split |= (vertical ? WSP_VERT : 0);
+    cmdinfo.cmdmod.cmod_split |= (mods->vertical ? WSP_VERT : 0);
 
-    bool horizontal;
-    OBJ_TO_BOOL(horizontal, mods.horizontal, false, "'mods.horizontal'");
-    cmdinfo.cmdmod.cmod_split |= (horizontal ? WSP_HOR : 0);
+    cmdinfo.cmdmod.cmod_split |= (mods->horizontal ? WSP_HOR : 0);
 
-    if (HAS_KEY(mods.split)) {
-      VALIDATE_T2(mods.split, kObjectTypeString, {
-        goto end;
-      });
-
-      if (*mods.split.data.string.data == NUL) {
+    if (HAS_KEY(mods, cmd_mods, split)) {
+      if (*mods->split.data == NUL) {
         // Empty string, do nothing.
-      } else if (strcmp(mods.split.data.string.data, "aboveleft") == 0
-                 || strcmp(mods.split.data.string.data, "leftabove") == 0) {
+      } else if (strcmp(mods->split.data, "aboveleft") == 0
+                 || strcmp(mods->split.data, "leftabove") == 0) {
         cmdinfo.cmdmod.cmod_split |= WSP_ABOVE;
-      } else if (strcmp(mods.split.data.string.data, "belowright") == 0
-                 || strcmp(mods.split.data.string.data, "rightbelow") == 0) {
+      } else if (strcmp(mods->split.data, "belowright") == 0
+                 || strcmp(mods->split.data, "rightbelow") == 0) {
         cmdinfo.cmdmod.cmod_split |= WSP_BELOW;
-      } else if (strcmp(mods.split.data.string.data, "topleft") == 0) {
+      } else if (strcmp(mods->split.data, "topleft") == 0) {
         cmdinfo.cmdmod.cmod_split |= WSP_TOP;
-      } else if (strcmp(mods.split.data.string.data, "botright") == 0) {
+      } else if (strcmp(mods->split.data, "botright") == 0) {
         cmdinfo.cmdmod.cmod_split |= WSP_BOT;
       } else {
         VALIDATE_S(false, "mods.split", "", {
@@ -662,20 +609,25 @@ String nvim_cmd(uint64_t channel_id, Dict(cmd) *cmd, Dict(cmd_opts) *opts, Error
       }
     }
 
-    OBJ_TO_CMOD_FLAG(CMOD_SILENT, mods.silent, false, "'mods.silent'");
-    OBJ_TO_CMOD_FLAG(CMOD_ERRSILENT, mods.emsg_silent, false, "'mods.emsg_silent'");
-    OBJ_TO_CMOD_FLAG(CMOD_UNSILENT, mods.unsilent, false, "'mods.unsilent'");
-    OBJ_TO_CMOD_FLAG(CMOD_SANDBOX, mods.sandbox, false, "'mods.sandbox'");
-    OBJ_TO_CMOD_FLAG(CMOD_NOAUTOCMD, mods.noautocmd, false, "'mods.noautocmd'");
-    OBJ_TO_CMOD_FLAG(CMOD_BROWSE, mods.browse, false, "'mods.browse'");
-    OBJ_TO_CMOD_FLAG(CMOD_CONFIRM, mods.confirm, false, "'mods.confirm'");
-    OBJ_TO_CMOD_FLAG(CMOD_HIDE, mods.hide, false, "'mods.hide'");
-    OBJ_TO_CMOD_FLAG(CMOD_KEEPALT, mods.keepalt, false, "'mods.keepalt'");
-    OBJ_TO_CMOD_FLAG(CMOD_KEEPJUMPS, mods.keepjumps, false, "'mods.keepjumps'");
-    OBJ_TO_CMOD_FLAG(CMOD_KEEPMARKS, mods.keepmarks, false, "'mods.keepmarks'");
-    OBJ_TO_CMOD_FLAG(CMOD_KEEPPATTERNS, mods.keeppatterns, false, "'mods.keeppatterns'");
-    OBJ_TO_CMOD_FLAG(CMOD_LOCKMARKS, mods.lockmarks, false, "'mods.lockmarks'");
-    OBJ_TO_CMOD_FLAG(CMOD_NOSWAPFILE, mods.noswapfile, false, "'mods.noswapfile'");
+#define OBJ_TO_CMOD_FLAG(flag, value) \
+  if (value) { \
+    cmdinfo.cmdmod.cmod_flags |= (flag); \
+  }
+
+    OBJ_TO_CMOD_FLAG(CMOD_SILENT, mods->silent);
+    OBJ_TO_CMOD_FLAG(CMOD_ERRSILENT, mods->emsg_silent);
+    OBJ_TO_CMOD_FLAG(CMOD_UNSILENT, mods->unsilent);
+    OBJ_TO_CMOD_FLAG(CMOD_SANDBOX, mods->sandbox);
+    OBJ_TO_CMOD_FLAG(CMOD_NOAUTOCMD, mods->noautocmd);
+    OBJ_TO_CMOD_FLAG(CMOD_BROWSE, mods->browse);
+    OBJ_TO_CMOD_FLAG(CMOD_CONFIRM, mods->confirm);
+    OBJ_TO_CMOD_FLAG(CMOD_HIDE, mods->hide);
+    OBJ_TO_CMOD_FLAG(CMOD_KEEPALT, mods->keepalt);
+    OBJ_TO_CMOD_FLAG(CMOD_KEEPJUMPS, mods->keepjumps);
+    OBJ_TO_CMOD_FLAG(CMOD_KEEPMARKS, mods->keepmarks);
+    OBJ_TO_CMOD_FLAG(CMOD_KEEPPATTERNS, mods->keeppatterns);
+    OBJ_TO_CMOD_FLAG(CMOD_LOCKMARKS, mods->lockmarks);
+    OBJ_TO_CMOD_FLAG(CMOD_NOSWAPFILE, mods->noswapfile);
 
     if (cmdinfo.cmdmod.cmod_flags & CMOD_ERRSILENT) {
       // CMOD_ERRSILENT must imply CMOD_SILENT, otherwise apply_cmdmod() and undo_cmdmod() won't
@@ -699,13 +651,13 @@ String nvim_cmd(uint64_t channel_id, Dict(cmd) *cmd, Dict(cmd_opts) *opts, Error
   garray_T * const save_capture_ga = capture_ga;
   const int save_msg_col = msg_col;
 
-  if (output) {
+  if (opts->output) {
     ga_init(&capture_local, 1, 80);
     capture_ga = &capture_local;
   }
 
   TRY_WRAP(err, {
-    if (output) {
+    if (opts->output) {
       msg_silent++;
       msg_col = 0;  // prevent leading spaces
     }
@@ -714,7 +666,7 @@ String nvim_cmd(uint64_t channel_id, Dict(cmd) *cmd, Dict(cmd_opts) *opts, Error
       execute_cmd(&ea, &cmdinfo, false);
     });
 
-    if (output) {
+    if (opts->output) {
       capture_ga = save_capture_ga;
       msg_silent = save_msg_silent;
       // Put msg_col back where it was, since nothing should have been written.
@@ -726,7 +678,7 @@ String nvim_cmd(uint64_t channel_id, Dict(cmd) *cmd, Dict(cmd_opts) *opts, Error
     goto clear_ga;
   }
 
-  if (output && capture_local.ga_len > 1) {
+  if (opts->output && capture_local.ga_len > 1) {
     retv = (String){
       .data = capture_local.ga_data,
       .size = (size_t)capture_local.ga_len,
@@ -740,7 +692,7 @@ String nvim_cmd(uint64_t channel_id, Dict(cmd) *cmd, Dict(cmd_opts) *opts, Error
     goto end;
   }
 clear_ga:
-  if (output) {
+  if (opts->output) {
     ga_clear(&capture_local);
   }
 end:
@@ -1037,7 +989,7 @@ void create_user_command(uint64_t channel_id, String name, Object command, Dict(
              name.data, {
     goto err;
   });
-  VALIDATE((!HAS_KEY(opts->range) || !HAS_KEY(opts->count)), "%s",
+  VALIDATE((!HAS_KEY(opts, user_command, range) || !HAS_KEY(opts, user_command, count)), "%s",
            "Cannot use both 'range' and 'count'", {
     goto err;
   });
@@ -1075,13 +1027,14 @@ void create_user_command(uint64_t channel_id, String name, Object command, Dict(
         goto err;
       });
     }
-  } else if (HAS_KEY(opts->nargs)) {
+  } else if (HAS_KEY(opts, user_command, nargs)) {
     VALIDATE_S(false, "nargs", "", {
       goto err;
     });
   }
 
-  VALIDATE((!HAS_KEY(opts->complete) || argt), "%s", "'complete' used without 'nargs'", {
+  VALIDATE((!HAS_KEY(opts, user_command, complete) || argt),
+           "%s", "'complete' used without 'nargs'", {
     goto err;
   });
 
@@ -1101,7 +1054,7 @@ void create_user_command(uint64_t channel_id, String name, Object command, Dict(
     argt |= EX_RANGE | EX_ZEROR;
     def = opts->range.data.integer;
     addr_type_arg = ADDR_LINES;
-  } else if (HAS_KEY(opts->range)) {
+  } else if (HAS_KEY(opts, user_command, range)) {
     VALIDATE_S(false, "range", "", {
       goto err;
     });
@@ -1117,13 +1070,13 @@ void create_user_command(uint64_t channel_id, String name, Object command, Dict(
     argt |= EX_COUNT | EX_ZEROR | EX_RANGE;
     addr_type_arg = ADDR_OTHER;
     def = opts->count.data.integer;
-  } else if (HAS_KEY(opts->count)) {
+  } else if (HAS_KEY(opts, user_command, count)) {
     VALIDATE_S(false, "count", "", {
       goto err;
     });
   }
 
-  if (HAS_KEY(opts->addr)) {
+  if (HAS_KEY(opts, user_command, addr)) {
     VALIDATE_T("addr", kObjectTypeString, opts->addr.type, {
       goto err;
     });
@@ -1139,31 +1092,23 @@ void create_user_command(uint64_t channel_id, String name, Object command, Dict(
     }
   }
 
-  if (api_object_to_bool(opts->bang, "bang", false, err)) {
+  if (opts->bang) {
     argt |= EX_BANG;
-  } else if (ERROR_SET(err)) {
-    goto err;
   }
 
-  if (api_object_to_bool(opts->bar, "bar", false, err)) {
+  if (opts->bar) {
     argt |= EX_TRLBAR;
-  } else if (ERROR_SET(err)) {
-    goto err;
   }
 
-  if (api_object_to_bool(opts->register_, "register", false, err)) {
+  if (opts->register_) {
     argt |= EX_REGSTR;
-  } else if (ERROR_SET(err)) {
-    goto err;
   }
 
-  if (api_object_to_bool(opts->keepscript, "keepscript", false, err)) {
+  if (opts->keepscript) {
     argt |= EX_KEEPSCRIPT;
-  } else if (ERROR_SET(err)) {
-    goto err;
   }
 
-  bool force = api_object_to_bool(opts->force, "force", true, err);
+  bool force = GET_BOOL_OR_TRUE(opts, user_command, force);
   if (ERROR_SET(err)) {
     goto err;
   }
@@ -1178,13 +1123,13 @@ void create_user_command(uint64_t channel_id, String name, Object command, Dict(
                "complete", opts->complete.data.string.data, {
       goto err;
     });
-  } else if (HAS_KEY(opts->complete)) {
+  } else if (HAS_KEY(opts, user_command, complete)) {
     VALIDATE_EXP(false, "complete", "Function or String", NULL, {
       goto err;
     });
   }
 
-  if (HAS_KEY(opts->preview)) {
+  if (HAS_KEY(opts, user_command, preview)) {
     VALIDATE_T("preview", kObjectTypeLuaRef, opts->preview.type, {
       goto err;
     });
@@ -1254,13 +1199,12 @@ Dictionary nvim_buf_get_commands(Buffer buffer, Dict(get_commands) *opts, Error
   FUNC_API_SINCE(4)
 {
   bool global = (buffer == -1);
-  bool builtin = api_object_to_bool(opts->builtin, "builtin", false, err);
   if (ERROR_SET(err)) {
     return (Dictionary)ARRAY_DICT_INIT;
   }
 
   if (global) {
-    if (builtin) {
+    if (opts->builtin) {
       api_set_error(err, kErrorTypeValidation, "builtin=true not implemented");
       return (Dictionary)ARRAY_DICT_INIT;
     }
@@ -1268,7 +1212,7 @@ Dictionary nvim_buf_get_commands(Buffer buffer, Dict(get_commands) *opts, Error
   }
 
   buf_T *buf = find_buffer_by_handle(buffer, err);
-  if (builtin || !buf) {
+  if (opts->builtin || !buf) {
     return (Dictionary)ARRAY_DICT_INIT;
   }
   return commands_array(buf);
diff --git a/src/nvim/api/deprecated.c b/src/nvim/api/deprecated.c
index 2e3ebd7c39..f5a77ece7e 100644
--- a/src/nvim/api/deprecated.c
+++ b/src/nvim/api/deprecated.c
@@ -35,8 +35,7 @@ String nvim_exec(uint64_t channel_id, String src, Boolean output, Error *err)
   FUNC_API_SINCE(7)
   FUNC_API_DEPRECATED_SINCE(11)
 {
-  Dict(exec_opts) opts = { 0 };
-  opts.output = BOOLEAN_OBJ(output);
+  Dict(exec_opts) opts = { .output = output };
   return exec_impl(channel_id, src, &opts, err);
 }
 
@@ -46,8 +45,7 @@ String nvim_command_output(uint64_t channel_id, String command, Error *err)
   FUNC_API_SINCE(1)
   FUNC_API_DEPRECATED_SINCE(7)
 {
-  Dict(exec_opts) opts = { 0 };
-  opts.output = BOOLEAN_OBJ(true);
+  Dict(exec_opts) opts = { .output = true };
   return exec_impl(channel_id, command, &opts, err);
 }
 
diff --git a/src/nvim/api/extmark.c b/src/nvim/api/extmark.c
index d254373eb0..8a60d81649 100644
--- a/src/nvim/api/extmark.c
+++ b/src/nvim/api/extmark.c
@@ -10,6 +10,7 @@
 #include "lauxlib.h"
 #include "nvim/api/extmark.h"
 #include "nvim/api/private/defs.h"
+#include "nvim/api/private/dispatch.h"
 #include "nvim/api/private/helpers.h"
 #include "nvim/api/private/validate.h"
 #include "nvim/buffer_defs.h"
@@ -581,40 +582,32 @@ Integer nvim_buf_set_extmark(Buffer buffer, Integer ns_id, Integer line, Integer
   });
 
   uint32_t id = 0;
-  if (HAS_KEY(opts->id)) {
-    VALIDATE_EXP((opts->id.type == kObjectTypeInteger && opts->id.data.integer > 0),
-                 "id", "positive Integer", NULL, {
+  if (HAS_KEY(opts, set_extmark, id)) {
+    VALIDATE_EXP((opts->id > 0), "id", "positive Integer", NULL, {
       goto error;
     });
 
-    id = (uint32_t)opts->id.data.integer;
+    id = (uint32_t)opts->id;
   }
 
   int line2 = -1;
+  bool did_end_line = false;
 
   // For backward compatibility we support "end_line" as an alias for "end_row"
-  if (HAS_KEY(opts->end_line)) {
-    VALIDATE(!HAS_KEY(opts->end_row), "%s", "cannot use both 'end_row' and 'end_line'", {
+  if (HAS_KEY(opts, set_extmark, end_line)) {
+    VALIDATE(!HAS_KEY(opts, set_extmark, end_row),
+             "%s", "cannot use both 'end_row' and 'end_line'", {
       goto error;
     });
-    opts->end_row = opts->end_line;
-  }
 
-#define OPTION_TO_BOOL(target, name, val) \
-  target = api_object_to_bool(opts->name, #name, val, err); \
-  if (ERROR_SET(err)) { \
-    goto error; \
+    opts->end_row = opts->end_line;
+    did_end_line = true;
   }
 
-  bool strict = true;
-  OPTION_TO_BOOL(strict, strict, true);
-
-  if (HAS_KEY(opts->end_row)) {
-    VALIDATE_T("end_row", kObjectTypeInteger, opts->end_row.type, {
-      goto error;
-    });
+  bool strict = GET_BOOL_OR_TRUE(opts, set_extmark, strict);
 
-    Integer val = opts->end_row.data.integer;
+  if (HAS_KEY(opts, set_extmark, end_row) || did_end_line) {
+    Integer val = opts->end_row;
     VALIDATE_RANGE((val >= 0 && !(val > buf->b_ml.ml_line_count && strict)), "end_row", {
       goto error;
     });
@@ -622,12 +615,8 @@ Integer nvim_buf_set_extmark(Buffer buffer, Integer ns_id, Integer line, Integer
   }
 
   colnr_T col2 = -1;
-  if (HAS_KEY(opts->end_col)) {
-    VALIDATE_T("end_col", kObjectTypeInteger, opts->end_col.type, {
-      goto error;
-    });
-
-    Integer val = opts->end_col.data.integer;
+  if (HAS_KEY(opts, set_extmark, end_col)) {
+    Integer val = opts->end_col;
     VALIDATE_RANGE((val >= 0 && val <= MAXCOL), "end_col", {
       goto error;
     });
@@ -636,6 +625,7 @@ Integer nvim_buf_set_extmark(Buffer buffer, Integer ns_id, Integer line, Integer
 
   // uncrustify:off
 
+  // TODO(bfredl): keyset type alias for hl_group? (nil|int|string)
   struct {
     const char *name;
     Object *opt;
@@ -652,7 +642,7 @@ Integer nvim_buf_set_extmark(Buffer buffer, Integer ns_id, Integer line, Integer
   // uncrustify:on
 
   for (int j = 0; hls[j].name && hls[j].