Merge pull request #26458 from famiu/refactor/options/optionindex

src/nvim/CMakeLists.txt

@@ -324,6 +324,7 @@ set(GENERATED_KEYSETS_DEFS ${GENERATED_DIR}/keysets_defs.generated.h)
 set(GENERATED_EVENTS_ENUM ${GENERATED_INCLUDES_DIR}/auevents_enum.generated.h)
 set(GENERATED_EVENTS_NAMES_MAP ${GENERATED_DIR}/auevents_name_map.generated.h)
 set(GENERATED_OPTIONS ${GENERATED_DIR}/options.generated.h)
+set(GENERATED_OPTIONS_ENUM ${GENERATED_DIR}/options_enum.generated.h)
 set(EX_CMDS_GENERATOR ${GENERATOR_DIR}/gen_ex_cmds.lua)
 set(FUNCS_GENERATOR ${GENERATOR_DIR}/gen_eval.lua)
 set(EVENTS_GENERATOR ${GENERATOR_DIR}/gen_events.lua)
@@ -668,8 +669,8 @@ add_custom_command(OUTPUT ${GENERATED_EVENTS_ENUM} ${GENERATED_EVENTS_NAMES_MAP}
   DEPENDS ${LUA_GEN_DEPS} ${EVENTS_GENERATOR} ${CMAKE_CURRENT_LIST_DIR}/auevents.lua
 )
 
-add_custom_command(OUTPUT ${GENERATED_OPTIONS}
+add_custom_command(OUTPUT ${GENERATED_OPTIONS} ${GENERATED_OPTIONS_ENUM}
-  COMMAND ${LUA_GEN} ${OPTIONS_GENERATOR} ${GENERATED_OPTIONS}
+  COMMAND ${LUA_GEN} ${OPTIONS_GENERATOR} ${GENERATED_OPTIONS} ${GENERATED_OPTIONS_ENUM}
   DEPENDS ${LUA_GEN_DEPS} ${OPTIONS_GENERATOR} ${CMAKE_CURRENT_LIST_DIR}/options.lua
 )
 

src/nvim/api/deprecated.c

@@ -643,7 +643,7 @@ static Object get_option_from(void *from, OptReqScope req_scope, String name, Er
     return (Object)OBJECT_INIT;
   });
 
-  OptVal value = get_option_value_strict(name.data, req_scope, from, err);
+  OptVal value = get_option_value_strict(findoption(name.data), req_scope, from, err);
   if (ERROR_SET(err)) {
     return (Object)OBJECT_INIT;
   }
@@ -669,8 +669,8 @@ static void set_option_to(uint64_t channel_id, void *to, OptReqScope req_scope,
     return;
   });
 
-  int flags = get_option_attrs(name.data);
+  OptIndex opt_idx = findoption(name.data);
-  VALIDATE_S(flags != 0, "option name", name.data, {
+  VALIDATE_S(opt_idx != kOptInvalid, "option name", name.data, {
     return;
   });
 
@@ -685,13 +685,14 @@ static void set_option_to(uint64_t channel_id, void *to, OptReqScope req_scope,
     return;
   });
 
+  int attrs = get_option_attrs(opt_idx);
   // For global-win-local options -> setlocal
   // For        win-local options -> setglobal and setlocal (opt_flags == 0)
-  const int opt_flags = (req_scope == kOptReqWin && !(flags & SOPT_GLOBAL))
+  const int opt_flags = (req_scope == kOptReqWin && !(attrs & SOPT_GLOBAL))
                         ? 0
                         : (req_scope == kOptReqGlobal) ? OPT_GLOBAL : OPT_LOCAL;
 
   WITH_SCRIPT_CONTEXT(channel_id, {
-    set_option_value_for(name.data, optval, opt_flags, req_scope, to, err);
+    set_option_value_for(name.data, opt_idx, optval, opt_flags, req_scope, to, err);
   });
 }

src/nvim/api/options.c

@@ -23,9 +23,9 @@
 # include "api/options.c.generated.h"
 #endif
 
-static int validate_option_value_args(Dict(option) *opts, char *name, int *scope,
+static int validate_option_value_args(Dict(option) *opts, char *name, OptIndex *opt_idxp,
-                                      OptReqScope *req_scope, void **from, char **filetype,
+                                      int *scope, OptReqScope *req_scope, void **from,
-                                      Error *err)
+                                      char **filetype, Error *err)
 {
 #define HAS_KEY_X(d, v) HAS_KEY(d, option, v)
   if (HAS_KEY_X(opts, scope)) {
@@ -79,7 +79,8 @@ static int validate_option_value_args(Dict(option) *opts, char *name, int *scope
     return FAIL;
   });
 
-  int flags = get_option_attrs(name);
+  *opt_idxp = findoption(name);
+  int flags = get_option_attrs(*opt_idxp);
   if (flags == 0) {
     // hidden or unknown option
     api_set_error(err, kErrorTypeValidation, "Unknown option '%s'", name);
@@ -119,10 +120,10 @@ static buf_T *do_ft_buf(char *filetype, aco_save_T *aco, Error *err)
   aucmd_prepbuf(aco, ftbuf);
 
   TRY_WRAP(err, {
-    set_option_value("bufhidden", STATIC_CSTR_AS_OPTVAL("hide"), OPT_LOCAL);
+    set_option_value(kOptBufhidden, STATIC_CSTR_AS_OPTVAL("hide"), OPT_LOCAL);
-    set_option_value("buftype", STATIC_CSTR_AS_OPTVAL("nofile"), OPT_LOCAL);
+    set_option_value(kOptBuftype, STATIC_CSTR_AS_OPTVAL("nofile"), OPT_LOCAL);
-    set_option_value("swapfile", BOOLEAN_OPTVAL(false), OPT_LOCAL);
+    set_option_value(kOptSwapfile, BOOLEAN_OPTVAL(false), OPT_LOCAL);
-    set_option_value("modeline", BOOLEAN_OPTVAL(false), OPT_LOCAL);  // 'nomodeline'
+    set_option_value(kOptModeline, BOOLEAN_OPTVAL(false), OPT_LOCAL);  // 'nomodeline'
 
     ftbuf->b_p_ft = xstrdup(filetype);
     do_filetype_autocmd(ftbuf, false);
@@ -152,12 +153,14 @@ static buf_T *do_ft_buf(char *filetype, aco_save_T *aco, Error *err)
 Object nvim_get_option_value(String name, Dict(option) *opts, Error *err)
   FUNC_API_SINCE(9)
 {
+  OptIndex opt_idx = 0;
   int scope = 0;
   OptReqScope req_scope = kOptReqGlobal;
   void *from = NULL;
   char *filetype = NULL;
 
-  if (!validate_option_value_args(opts, name.data, &scope, &req_scope, &from, &filetype, err)) {
+  if (!validate_option_value_args(opts, name.data, &opt_idx, &scope, &req_scope, &from, &filetype,
+                                  err)) {
     return (Object)OBJECT_INIT;
   }
 
@@ -173,7 +176,6 @@ Object nvim_get_option_value(String name, Dict(option) *opts, Error *err)
     from = ftbuf;
   }
 
-  int opt_idx = findoption(name.data);
   OptVal value = get_option_value_for(opt_idx, scope, req_scope, from, err);
   bool hidden = is_option_hidden(opt_idx);
 
@@ -217,10 +219,11 @@ void nvim_set_option_value(uint64_t channel_id, String name, Object value, Dict(
                            Error *err)
   FUNC_API_SINCE(9)
 {
+  OptIndex opt_idx = 0;
   int scope = 0;
   OptReqScope req_scope = kOptReqGlobal;
   void *to = NULL;
-  if (!validate_option_value_args(opts, name.data, &scope, &req_scope, &to, NULL, err)) {
+  if (!validate_option_value_args(opts, name.data, &opt_idx, &scope, &req_scope, &to, NULL, err)) {
     return;
   }
 
@@ -231,7 +234,7 @@ void nvim_set_option_value(uint64_t channel_id, String name, Object value, Dict(
   //
   // Then force scope to local since we don't want to change the global option
   if (req_scope == kOptReqWin && scope == 0) {
-    int flags = get_option_attrs(name.data);
+    int flags = get_option_attrs(opt_idx);
     if (flags & SOPT_GLOBAL) {
       scope = OPT_LOCAL;
     }
@@ -249,7 +252,7 @@ void nvim_set_option_value(uint64_t channel_id, String name, Object value, Dict(
   });
 
   WITH_SCRIPT_CONTEXT(channel_id, {
-    set_option_value_for(name.data, optval, scope, req_scope, to, err);
+    set_option_value_for(name.data, opt_idx, optval, scope, req_scope, to, err);
   });
 }
 
@@ -303,10 +306,12 @@ Dictionary nvim_get_all_options_info(Error *err)
 Dictionary nvim_get_option_info2(String name, Dict(option) *opts, Error *err)
   FUNC_API_SINCE(11)
 {
+  OptIndex opt_idx = 0;
   int scope = 0;
   OptReqScope req_scope = kOptReqGlobal;
   void *from = NULL;
-  if (!validate_option_value_args(opts, name.data, &scope, &req_scope, &from, NULL, err)) {
+  if (!validate_option_value_args(opts, name.data, &opt_idx, &scope, &req_scope, &from, NULL,
+                                  err)) {
     return (Dictionary)ARRAY_DICT_INIT;
   }
 
@@ -382,20 +387,14 @@ static void restore_option_context(void *const ctx, OptReqScope req_scope)
 
 /// Get attributes for an option.
 ///
-/// @param  name  Option name.
+/// @param  opt_idx  Option index in options[] table.
 ///
 /// @return  Option attributes.
 ///          0 for hidden or unknown option.
 ///          See SOPT_* in option_defs.h for other flags.
-int get_option_attrs(char *name)
+int get_option_attrs(OptIndex opt_idx)
 {
-  if (is_tty_option(name)) {
+  if (opt_idx == kOptInvalid) {
-    return SOPT_GLOBAL;
-  }
-
-  int opt_idx = findoption(name);
-
-  if (opt_idx < 0) {
     return 0;
   }
 
@@ -422,15 +421,13 @@ int get_option_attrs(char *name)
 
 /// Check if option has a value in the requested scope.
 ///
-/// @param  name       Option name.
+/// @param  opt_idx    Option index in options[] table.
 /// @param  req_scope  Requested option scope. See OptReqScope in option.h.
 ///
 /// @return  true if option has a value in the requested scope, false otherwise.
-static bool option_has_scope(char *name, OptReqScope req_scope)
+static bool option_has_scope(OptIndex opt_idx, OptReqScope req_scope)
 {
-  int opt_idx = findoption(name);
+  if (opt_idx == kOptInvalid) {
-
-  if (opt_idx < 0) {
     return false;
   }
 
@@ -458,7 +455,7 @@ static bool option_has_scope(char *name, OptReqScope req_scope)
 
 /// Get the option value in the requested scope.
 ///
-/// @param       name       Option name.
+/// @param       opt_idx    Option index in options[] table.
 /// @param       req_scope  Requested option scope. See OptReqScope in option.h.
 /// @param[in]   from       Pointer to buffer or window for local option value.
 /// @param[out]  err        Error message, if any.
@@ -466,17 +463,11 @@ static bool option_has_scope(char *name, OptReqScope req_scope)
 /// @return  Option value in the requested scope. Returns a Nil option value if option is not found,
 /// hidden or if it isn't present in the requested scope. (i.e. has no global, window-local or
 /// buffer-local value depending on opt_scope).
-OptVal get_option_value_strict(char *name, OptReqScope req_scope, void *from, Error *err)
+OptVal get_option_value_strict(OptIndex opt_idx, OptReqScope req_scope, void *from, Error *err)
 {
-  if (!option_has_scope(name, req_scope)) {
+  if (opt_idx == kOptInvalid || !option_has_scope(opt_idx, req_scope)) {
     return NIL_OPTVAL;
   }
-  if (is_tty_option(name)) {
-    return get_tty_option(name);
-  }
-
-  int opt_idx = findoption(name);
-  assert(opt_idx != 0);  // option_has_scope() already verifies if option name is valid.
 
   vimoption_T *opt = get_option(opt_idx);
   switchwin_T switchwin;
@@ -509,8 +500,8 @@ OptVal get_option_value_strict(char *name, OptReqScope req_scope, void *from, Er
 /// @param[out]  err        Error message, if any.
 ///
 /// @return  Option value. Must be freed by caller.
-OptVal get_option_value_for(int opt_idx, int scope, const OptReqScope req_scope, void *const from,
+OptVal get_option_value_for(OptIndex opt_idx, int scope, const OptReqScope req_scope,
-                            Error *err)
+                            void *const from, Error *err)
 {
   switchwin_T switchwin;
   aco_save_T aco;
@@ -533,14 +524,16 @@ OptVal get_option_value_for(int opt_idx, int scope, const OptReqScope req_scope,
 
 /// Set option value for buffer / window.
 ///
-/// @param[in]   name        Option name.
+/// @param       name        Option name.
+/// @param       opt_idx     Option index in options[] table.
 /// @param[in]   value       Option value.
 /// @param[in]   opt_flags   Flags: OPT_LOCAL, OPT_GLOBAL, or 0 (both).
 /// @param       req_scope   Requested option scope. See OptReqScope in option.h.
 /// @param[in]   from        Target buffer/window.
 /// @param[out]  err         Error message, if any.
-void set_option_value_for(const char *const name, OptVal value, const int opt_flags,
+void set_option_value_for(const char *name, OptIndex opt_idx, OptVal value, const int opt_flags,
                           const OptReqScope req_scope, void *const from, Error *err)
+  FUNC_ATTR_NONNULL_ARG(1)
 {
   switchwin_T switchwin;
   aco_save_T aco;
@@ -552,7 +545,7 @@ void set_option_value_for(const char *const name, OptVal value, const int opt_fl
     return;
   }
 
-  const char *const errmsg = set_option_value(name, value, opt_flags);
+  const char *const errmsg = set_option_value_handle_tty(name, opt_idx, value, opt_flags);
   if (errmsg) {
     api_set_error(err, kErrorTypeException, "%s", errmsg);
   }

src/nvim/api/vim.c

@@ -948,8 +948,8 @@ Buffer nvim_create_buf(Boolean listed, Boolean scratch, Error *err)
   buf_copy_options(buf, BCO_ENTER | BCO_NOHELP);
 
   if (scratch) {
-    set_string_option_direct_in_buf(buf, "bufhidden", -1, "hide", OPT_LOCAL, 0);
+    set_string_option_direct_in_buf(buf, kOptBufhidden, "hide", OPT_LOCAL, 0);
-    set_string_option_direct_in_buf(buf, "buftype", -1, "nofile", OPT_LOCAL, 0);
+    set_string_option_direct_in_buf(buf, kOptBuftype, "nofile", OPT_LOCAL, 0);
     assert(buf->b_ml.ml_mfp->mf_fd < 0);  // ml_open() should not have opened swapfile already
     buf->b_p_swf = false;
     buf->b_p_ml = false;
@@ -2239,7 +2239,7 @@ Dictionary nvim_eval_statusline(String str, Dict(eval_statusline) *opts, Error *
                                buf,
                                sizeof(buf),
                                str.data,
-                               NULL,
+                               -1,
                                0,
                                fillchar,
                                maxwidth,

src/nvim/autocmd.c

@@ -704,7 +704,7 @@ char *au_event_disable(char *what)
   } else {
     STRCAT(new_ei, what);
   }
-  set_string_option_direct("ei", -1, new_ei, OPT_FREE, SID_NONE);
+  set_string_option_direct(kOptEventignore, new_ei, OPT_FREE, SID_NONE);
   xfree(new_ei);
   return save_ei;
 }
@@ -712,7 +712,7 @@ char *au_event_disable(char *what)
 void au_event_restore(char *old_ei)
 {
   if (old_ei != NULL) {
-    set_string_option_direct("ei", -1, old_ei, OPT_FREE, SID_NONE);
+    set_string_option_direct(kOptEventignore, old_ei, OPT_FREE, SID_NONE);
     xfree(old_ei);
   }
 }

src/nvim/buffer.c

@@ -3281,7 +3281,7 @@ void maketitle(void)
     if (*p_titlestring != NUL) {
       if (stl_syntax & STL_IN_TITLE) {
         build_stl_str_hl(curwin, buf, sizeof(buf), p_titlestring,
-                         "titlestring", 0, 0, maxlen, NULL, NULL, NULL);
+                         kOptTitlestring, 0, 0, maxlen, NULL, NULL, NULL);
         title_str = buf;
       } else {
         title_str = p_titlestring;
@@ -3386,7 +3386,7 @@ void maketitle(void)
     if (*p_iconstring != NUL) {
       if (stl_syntax & STL_IN_ICON) {
         build_stl_str_hl(curwin, icon_str, sizeof(buf), p_iconstring,
-                         "iconstring", 0, 0, 0, NULL, NULL, NULL);
+                         kOptIconstring, 0, 0, 0, NULL, NULL, NULL);
       } else {
         icon_str = p_iconstring;
       }
@@ -4147,9 +4147,9 @@ int buf_open_scratch(handle_T bufnr, char *bufname)
   apply_autocmds(EVENT_BUFFILEPRE, NULL, NULL, false, curbuf);
   (void)setfname(curbuf, bufname, NULL, true);
   apply_autocmds(EVENT_BUFFILEPOST, NULL, NULL, false, curbuf);
-  set_option_value_give_err("bh", STATIC_CSTR_AS_OPTVAL("hide"), OPT_LOCAL);
+  set_option_value_give_err(kOptBufhidden, STATIC_CSTR_AS_OPTVAL("hide"), OPT_LOCAL);
-  set_option_value_give_err("bt", STATIC_CSTR_AS_OPTVAL("nofile"), OPT_LOCAL);
+  set_option_value_give_err(kOptBuftype, STATIC_CSTR_AS_OPTVAL("nofile"), OPT_LOCAL);
-  set_option_value_give_err("swf", BOOLEAN_OPTVAL(false), OPT_LOCAL);
+  set_option_value_give_err(kOptSwapfile, BOOLEAN_OPTVAL(false), OPT_LOCAL);
   RESET_BINDING(curwin);
   return OK;
 }

src/nvim/context.c

@@ -138,8 +138,8 @@ bool ctx_restore(Context *ctx, const int flags)
     free_ctx = true;
   }
 
-  OptVal op_shada = get_option_value(findoption("shada"), OPT_GLOBAL);
+  OptVal op_shada = get_option_value(kOptShada, OPT_GLOBAL);
-  set_option_value("shada", STATIC_CSTR_AS_OPTVAL("!,'100,%"), OPT_GLOBAL);
+  set_option_value(kOptShada, STATIC_CSTR_AS_OPTVAL("!,'100,%"), OPT_GLOBAL);
 
   if (flags & kCtxRegs) {
     ctx_restore_regs(ctx);
@@ -165,7 +165,7 @@ bool ctx_restore(Context *ctx, const int flags)
     ctx_free(ctx);
   }
 
-  set_option_value("shada", op_shada, OPT_GLOBAL);
+  set_option_value(kOptShada, op_shada, OPT_GLOBAL);
   optval_free(op_shada);
 
   return true;

src/nvim/diff.c

@@ -1389,7 +1389,7 @@ static void set_diff_option(win_T *wp, bool value)
   curwin = wp;
   curbuf = curwin->w_buffer;
   curbuf->b_ro_locked++;
-  set_option_value_give_err("diff", BOOLEAN_OPTVAL(value), OPT_LOCAL);
+  set_option_value_give_err(kOptDiff, BOOLEAN_OPTVAL(value), OPT_LOCAL);
   curbuf->b_ro_locked--;
   curwin = old_curwin;
   curbuf = curwin->w_buffer;
@@ -1430,7 +1430,7 @@ void diff_win_options(win_T *wp, int addbuf)
     }
     wp->w_p_fdm_save = xstrdup(wp->w_p_fdm);
   }
-  set_string_option_direct_in_win(wp, "fdm", -1, "diff", OPT_LOCAL | OPT_FREE, 0);
+  set_string_option_direct_in_win(wp, kOptFoldmethod, "diff", OPT_LOCAL | OPT_FREE, 0);
 
   if (!wp->w_p_diff) {
     wp->w_p_fen_save = wp->w_p_fen;

src/nvim/eval.c

@@ -681,7 +681,7 @@ int eval_charconvert(const char *const enc_from, const char *const enc_to,
   set_vim_var_string(VV_CC_TO, enc_to, -1);
   set_vim_var_string(VV_FNAME_IN, fname_from, -1);
   set_vim_var_string(VV_FNAME_OUT, fname_to, -1);
-  sctx_T *ctx = get_option_sctx("charconvert");
+  sctx_T *ctx = get_option_sctx(kOptCharconvert);
   if (ctx != NULL) {
     current_sctx = *ctx;
   }
@@ -710,7 +710,7 @@ void eval_diff(const char *const origfile, const char *const newfile, const char
   set_vim_var_string(VV_FNAME_NEW, newfile, -1);
   set_vim_var_string(VV_FNAME_OUT, outfile, -1);
 
-  sctx_T *ctx = get_option_sctx("diffexpr");
+  sctx_T *ctx = get_option_sctx(kOptDiffexpr);
   if (ctx != NULL) {
     current_sctx = *ctx;
   }
@@ -732,7 +732,7 @@ void eval_patch(const char *const origfile, const char *const difffile, const ch
   set_vim_var_string(VV_FNAME_DIFF, difffile, -1);
   set_vim_var_string(VV_FNAME_OUT, outfile, -1);
 
-  sctx_T *ctx = get_option_sctx("patchexpr");
+  sctx_T *ctx = get_option_sctx(kOptPatchexpr);
   if (ctx != NULL) {
     current_sctx = *ctx;
   }
@@ -1134,7 +1134,7 @@ list_T *eval_spell_expr(char *badword, char *expr)
   if (p_verbose == 0) {
     emsg_off++;
   }
-  sctx_T *ctx = get_option_sctx("spellsuggest");
+  sctx_T *ctx = get_option_sctx(kOptSpellsuggest);
   if (ctx != NULL) {
     current_sctx = *ctx;
   }
@@ -1278,7 +1278,7 @@ void *call_func_retlist(const char *func, int argc, typval_T *argv)
 int eval_foldexpr(win_T *wp, int *cp)
 {
   const sctx_T saved_sctx = current_sctx;
-  const bool use_sandbox = was_set_insecurely(wp, "foldexpr", OPT_LOCAL);
+  const bool use_sandbox = was_set_insecurely(wp, kOptFoldexpr, OPT_LOCAL);
 
   char *arg = wp->w_p_fde;
   current_sctx = wp->w_p_script_ctx[WV_FDE].script_ctx;
@@ -1326,7 +1326,7 @@ int eval_foldexpr(win_T *wp, int *cp)
 /// Evaluate 'foldtext', returning an Array or a String (NULL_STRING on failure).
 Object eval_foldtext(win_T *wp)
 {
-  const bool use_sandbox = was_set_insecurely(wp, "foldtext", OPT_LOCAL);
+  const bool use_sandbox = was_set_insecurely(wp, kOptFoldtext, OPT_LOCAL);
   char *arg = wp->w_p_fdt;
   funccal_entry_T funccal_entry;
 
@@ -3788,9 +3788,9 @@ int eval_option(const char **const arg, typval_T *const rettv, const bool evalua
   *option_end = NUL;
 
   bool is_tty_opt = is_tty_option(*arg);
-  int opt_idx = is_tty_opt ? -1 : findoption(*arg);
+  OptIndex opt_idx = is_tty_opt ? kOptInvalid : findoption(*arg);
 
-  if (opt_idx < 0 && !is_tty_opt) {
+  if (opt_idx == kOptInvalid && !is_tty_opt) {
     // Only give error if result is going to be used.
     if (rettv != NULL) {
       semsg(_("E113: Unknown option: %s"), *arg);
@@ -8715,7 +8715,7 @@ char *do_string_sub(char *str, char *pat, char *sub, typval_T *expr, const char
     // If it's still empty it was changed and restored, need to restore in
     // the complicated way.
     if (*p_cpo == NUL) {
-      set_option_value_give_err("cpo", CSTR_AS_OPTVAL(save_cpo), 0);
+      set_option_value_give_err(kOptCpoptions, CSTR_AS_OPTVAL(save_cpo), 0);
     }
     free_string_option(save_cpo);
   }

src/nvim/eval/funcs.c

@@ -7239,7 +7239,7 @@ int do_searchpair(const char *spat, const char *mpat, const char *epat, int dir,
     // If it's still empty it was changed and restored, need to restore in
     // the complicated way.
     if (*p_cpo == NUL) {
-      set_option_value_give_err("cpo", CSTR_AS_OPTVAL(save_cpo), 0);
+      set_option_value_give_err(kOptCpoptions, CSTR_AS_OPTVAL(save_cpo), 0);
     }
     free_string_option(save_cpo);
   }

src/nvim/eval/vars.c

@@ -774,7 +774,7 @@ static char *ex_let_option(char *arg, typval_T *const tv, const bool is_const,
   *p = NUL;
 
   bool is_tty_opt = is_tty_option(arg);
-  int opt_idx = is_tty_opt ? -1 : findoption(arg);
+  OptIndex opt_idx = is_tty_opt ? kOptInvalid : findoption(arg);
   uint32_t opt_p_flags = get_option_flags(opt_idx);
   bool hidden = is_option_hidden(opt_idx);
   OptVal curval = is_tty_opt ? get_tty_option(arg) : get_option_value(opt_idx, scope);
@@ -834,7 +834,7 @@ static char *ex_let_option(char *arg, typval_T *const tv, const bool is_const,
     }
   }
 
-  const char *err = set_option_value(arg, newval, scope);
+  const char *err = set_option_value_handle_tty(arg, opt_idx, newval, scope);
   arg_end = p;
   if (err != NULL) {
     emsg(_(err));
@@ -1940,20 +1940,23 @@ typval_T optval_as_tv(OptVal value)
 /// Set option "varname" to the value of "varp" for the current buffer/window.
 static void set_option_from_tv(const char *varname, typval_T *varp)
 {
-  int opt_idx = findoption(varname);
+  OptIndex opt_idx = findoption(varname);
-  if (opt_idx < 0) {
+  if (opt_idx == kOptInvalid) {
     semsg(_(e_unknown_option2), varname);
     return;
   }
-  uint32_t opt_p_flags = get_option(opt_idx)->flags;
 
   bool error = false;
+  uint32_t opt_p_flags = get_option_flags(opt_idx);
   OptVal value = tv_to_optval(varp, varname, opt_p_flags, &error);
 
   if (!error) {
-    set_option_value_give_err(varname, value, OPT_LOCAL);
+    const char *errmsg = set_option_value_handle_tty(varname, opt_idx, value, OPT_LOCAL);
-  }
 
+    if (errmsg) {
+      emsg(errmsg);
+    }
+  }
   optval_free(value);
 }
 

src/nvim/ex_cmds.c

@@ -4265,7 +4265,7 @@ skip:
   // Show 'inccommand' preview if there are matched lines.
   if (cmdpreview_ns > 0 && !aborting()) {
     if (got_quit || profile_passed_limit(timeout)) {  // Too slow, disable.
-      set_string_option_direct("icm", -1, "", OPT_FREE, SID_NONE);
+      set_string_option_direct(kOptInccommand, "", OPT_FREE, SID_NONE);
     } else if (*p_icm != NUL && pat != NULL) {
       if (pre_hl_id == 0) {
         pre_hl_id = syn_check_group(S_LEN("Substitute"));
@@ -4544,8 +4544,8 @@ bool prepare_tagpreview(bool undo_sync)
   curwin->w_p_wfh = true;
   RESET_BINDING(curwin);                // don't take over 'scrollbind' and 'cursorbind'
   curwin->w_p_diff = false;             // no 'diff'
-  set_string_option_direct("fdc", -1,     // no 'foldcolumn'
+
-                           "0", OPT_FREE, SID_NONE);
+  set_string_option_direct(kOptFoldcolumn, "0", OPT_FREE, SID_NONE);  // no 'foldcolumn'
   return true;
 }
 
@@ -4564,7 +4564,7 @@ static int show_sub(exarg_T *eap, pos_T old_cusr, PreviewLines *preview_lines, i
   buf_T *cmdpreview_buf = NULL;
 
   // disable file info message
-  set_string_option_direct("shm", -1, "F", OPT_FREE, SID_NONE);
+  set_string_option_direct(kOptShortmess, "F", OPT_FREE, SID_NONE);
 
   // Update the topline to ensure that main window is on the correct line
   update_topline(curwin);
@@ -4665,7 +4665,7 @@ static int show_sub(exarg_T *eap, pos_T old_cusr, PreviewLines *preview_lines, i
 
   xfree(str);
 
-  set_string_option_direct("shm", -1, save_shm_p, OPT_FREE, SID_NONE);
+  set_string_option_direct(kOptShortmess, save_shm_p, OPT_FREE, SID_NONE);
   xfree(save_shm_p);
 
   return preview ? 2 : 1;

src/nvim/ex_docmd.c

@@ -2653,7 +2653,7 @@ static void apply_cmdmod(cmdmod_T *cmod)
     // Set 'eventignore' to "all".
     // First save the existing option value for restoring it later.
     cmod->cmod_save_ei = xstrdup(p_ei);
-    set_string_option_direct("ei", -1, "all", OPT_FREE, SID_NONE);
+    set_string_option_direct(kOptEventignore, "all", OPT_FREE, SID_NONE);
   }
 }
 
@@ -2673,7 +2673,7 @@ void undo_cmdmod(cmdmod_T *cmod)
 
   if (cmod->cmod_save_ei != NULL) {
     // Restore 'eventignore' to the value before ":noautocmd".
-    set_string_option_direct("ei", -1, cmod->cmod_save_ei, OPT_FREE, SID_NONE);
+    set_string_option_direct(kOptEventignore, cmod->cmod_save_ei, OPT_FREE, SID_NONE);
     free_string_option(cmod->cmod_save_ei);
     cmod->cmod_save_ei = NULL;
   }
@@ -7306,7 +7306,7 @@ static void ex_setfiletype(exarg_T *eap)
     arg += 9;
   }
 
-  set_option_value_give_err("filetype", CSTR_AS_OPTVAL(arg), OPT_LOCAL);
+  set_option_value_give_err(kOptFiletype, CSTR_AS_OPTVAL(arg), OPT_LOCAL);
   if (arg != eap->arg) {
     did_filetype = false;
   }

src/nvim/ex_getln.c

@@ -905,7 +905,7 @@ static uint8_t *command_line_enter(int firstc, int count, int indent, bool clear
     need_wait_return = false;
   }
 
-  set_string_option_direct("icm", -1, s->save_p_icm, OPT_FREE, SID_NONE);
+  set_string_option_direct(kOptInccommand, s->save_p_icm, OPT_FREE, SID_NONE);
   State = s->save_State;
   if (cmdpreview != save_cmdpreview) {
     cmdpreview = save_cmdpreview;  // restore preview state
@@ -4326,7 +4326,7 @@ static int open_cmdwin(void)
     return Ctrl_C;
   }
   // Command-line buffer has bufhidden=wipe, unlike a true "scratch" buffer.
-  set_option_value_give_err("bh", STATIC_CSTR_AS_OPTVAL("wipe"), OPT_LOCAL);
+  set_option_value_give_err(kOptBufhidden, STATIC_CSTR_AS_OPTVAL("wipe"), OPT_LOCAL);
   curbuf->b_p_ma = true;
   curwin->w_p_fen = false;
   curwin->w_p_rl = cmdmsg_rl;
@@ -4344,7 +4344,7 @@ static int open_cmdwin(void)
       add_map("<Tab>", "<C-X><C-V>", MODE_INSERT, true);
       add_map("<Tab>", "a<C-X><C-V>", MODE_NORMAL, true);
     }
-    set_option_value_give_err("ft", STATIC_CSTR_AS_OPTVAL("vim"), OPT_LOCAL);
+    set_option_value_give_err(kOptFiletype, STATIC_CSTR_AS_OPTVAL("vim"), OPT_LOCAL);
   }
   curbuf->b_ro_locked--;
 

src/nvim/fileio.c

@@ -1617,7 +1617,7 @@ failed:
     save_file_ff(curbuf);
     // If editing a new file: set 'fenc' for the current buffer.
     // Also for ":read ++edit file".
-    set_string_option_direct("fenc", -1, fenc, OPT_FREE | OPT_LOCAL, 0);
+    set_string_option_direct(kOptFileencoding, fenc, OPT_FREE | OPT_LOCAL, 0);
   }
   if (fenc_alloced) {
     xfree(fenc);
@@ -1965,7 +1965,7 @@ void set_forced_fenc(exarg_T *eap)
   }
 
   char *fenc = enc_canonize(eap->cmd + eap->force_enc);
-  set_string_option_direct("fenc", -1, fenc, OPT_FREE|OPT_LOCAL, 0);
+  set_string_option_direct(kOptFileencoding, fenc, OPT_FREE|OPT_LOCAL, 0);
   xfree(fenc);
 }
 

src/nvim/generators/gen_options.lua

@@ -1,4 +1,5 @@
 local options_file = arg[1]
+local options_enum_file = arg[2]
 
 local opt_fd = assert(io.open(options_file, 'w'))
 
@@ -41,6 +42,12 @@ local list_flags = {
   flagscomma = 'P_COMMA|P_FLAGLIST',
 }
 
+--- @param s string
+--- @return string
+local lowercase_to_titlecase = function(s)
+  return s:sub(1, 1):upper() .. s:sub(2)
+end
+
 --- @param o vim.option_meta
 --- @return string
 local function get_flags(o)
@@ -222,11 +229,25 @@ static vimoption_T options[] = {]])
 for i, o in ipairs(options.options) do
   dump_option(i, o)
 end
-w('  [' .. ('%u'):format(#options.options) .. ']={.fullname=NULL}')
 w('};')
 w('')
 
 for _, v in ipairs(defines) do
   w('#define ' .. v[1] .. ' ' .. v[2])
 end
+
+-- Generate options enum file
+opt_fd = assert(io.open(options_enum_file, 'w'))
+
+w('typedef enum {')
+w('  kOptInvalid = -1,')
+
+for i, o in ipairs(options.options) do
+  w(('  kOpt%s = %u,'):format(lowercase_to_titlecase(o.full_name), i - 1))
+end
+
+w('  // Option count, used when iterating through options')
+w('#define kOptIndexCount ' .. tostring(#options.options))
+w('} OptIndex;')
+
 opt_fd:close()

src/nvim/help.c

@@ -608,7 +608,7 @@ void cleanup_help_tags(int num_file, char **file)
 void prepare_help_buffer(void)
 {
   curbuf->b_help = true;
-  set_string_option_direct("buftype", -1, "help", OPT_FREE|OPT_LOCAL, 0);
+  set_string_option_direct(kOptBuftype, "help", OPT_FREE|OPT_LOCAL, 0);
 
   // Always set these options after jumping to a help tag, because the
   // user may have an autocommand that gets in the way.
@@ -617,13 +617,13 @@ void prepare_help_buffer(void)
   // Only set it when needed, buf_init_chartab() is some work.
   char *p = "!-~,^*,^|,^\",192-255";
   if (strcmp(curbuf->b_p_isk, p) != 0) {
-    set_string_option_direct("isk", -1, p, OPT_FREE|OPT_LOCAL, 0);
+    set_string_option_direct(kOptIskeyword, p, OPT_FREE|OPT_LOCAL, 0);
     check_buf_options(curbuf);
     (void)buf_init_chartab(curbuf, false);
   }
 
   // Don't use the global foldmethod.
-  set_string_option_direct("fdm", -1, "manual", OPT_FREE|OPT_LOCAL, 0);
+  set_string_option_direct(kOptFoldmethod, "manual", OPT_FREE|OPT_LOCAL, 0);
 
   curbuf->b_p_ts = 8;         // 'tabstop' is 8.
   curwin->w_p_list = false;   // No list mode.
@@ -649,7 +649,7 @@ void fix_help_buffer(void)
   // Set filetype to "help".
   if (strcmp(curbuf->b_p_ft, "help") != 0) {
     curbuf->b_ro_locked++;
-    set_option_value_give_err("ft", STATIC_CSTR_AS_OPTVAL("help"), OPT_LOCAL);
+    set_option_value_give_err(kOptFiletype, STATIC_CSTR_AS_OPTVAL("help"), OPT_LOCAL);
     curbuf->b_ro_locked--;
   }
 

src/nvim/highlight_group.c

@@ -1337,9 +1337,10 @@ void do_highlight(const char *line, const bool forceit, const bool init)
                   // wrong.
                   if (dark != -1
                       && dark != (*p_bg == 'd')
-                      && !option_was_set("bg")) {
+                      && !option_was_set(kOptBackground)) {
-                    set_option_value_give_err("bg", CSTR_AS_OPTVAL(dark ? "dark" : "light"), 0);
+                    set_option_value_give_err(kOptBackground,
-                    reset_option_was_set("bg");
+                                              CSTR_AS_OPTVAL(dark ? "dark" : "light"), 0);
+                    reset_option_was_set(kOptBackground);
                   }
                 }
               }

src/nvim/indent.c

@@ -1091,7 +1091,7 @@ void ex_retab(exarg_T *eap)
     colnr_T *old_vts_ary = curbuf->b_p_vts_array;
 
     if (tabstop_count(old_vts_ary) > 0 || tabstop_count(new_vts_array) > 1) {
-      set_string_option_direct("vts", -1, new_ts_str, OPT_FREE | OPT_LOCAL, 0);
+      set_string_option_direct(kOptVartabstop, new_ts_str, OPT_FREE | OPT_LOCAL, 0);
       curbuf->b_p_vts_array = new_vts_array;
       xfree(old_vts_ary);
     } else {
@@ -1115,7 +1115,7 @@ int get_expr_indent(void)
   colnr_T save_curswant;
   int save_set_curswant;
   int save_State;
-  int use_sandbox = was_set_insecurely(curwin, "indentexpr", OPT_LOCAL);
+  int use_sandbox = was_set_insecurely(curwin, kOptIndentexpr, OPT_LOCAL);
   const sctx_T save_sctx = current_sctx;
 
   // Save and restore cursor position and curswant, in case it was changed

src/nvim/main.c

@@ -1123,7 +1123,7 @@ static void command_line_scan(mparm_T *parmp)
         } else if (STRNICMP(argv[0] + argv_idx, "clean", 5) == 0) {
           parmp->use_vimrc = "NONE";
           parmp->clean = true;
-          set_option_value_give_err("shadafile", STATIC_CSTR_AS_OPTVAL("NONE"), 0);
+          set_option_value_give_err(kOptShadafile, STATIC_CSTR_AS_OPTVAL("NONE"), 0);
         } else if (STRNICMP(argv[0] + argv_idx, "luamod-dev", 9) == 0) {
           nlua_disable_preload = true;
         } else {
@@ -1137,7 +1137,7 @@ static void command_line_scan(mparm_T *parmp)
         }
         break;
       case 'A':    // "-A" start in Arabic mode.
-        set_option_value_give_err("arabic", BOOLEAN_OPTVAL(true), 0);
+        set_option_value_give_err(kOptArabic, BOOLEAN_OPTVAL(true), 0);
         break;
       case 'b':    // "-b" binary mode.
         // Needs to be effective before expanding file names, because
@@ -1167,8 +1167,8 @@ static void command_line_scan(mparm_T *parmp)
         usage();
         os_exit(0);
       case 'H':    // "-H" start in Hebrew mode: rl + keymap=hebrew set.
-        set_option_value_give_err("keymap", STATIC_CSTR_AS_OPTVAL("hebrew"), 0);
+        set_option_value_give_err(kOptKeymap, STATIC_CSTR_AS_OPTVAL("hebrew"), 0);
-        set_option_value_give_err("rl", BOOLEAN_OPTVAL(true), 0);
+        set_option_value_give_err(kOptRightleft, BOOLEAN_OPTVAL(true), 0);
         break;
       case 'M':    // "-M"  no changes or writing of files
         reset_modifiable();
@@ -1248,7 +1248,7 @@ static void command_line_scan(mparm_T *parmp)
         // default is 10: a little bit verbose
         p_verbose = get_number_arg(argv[0], &argv_idx, 10);
         if (argv[0][argv_idx] != NUL) {
-          set_option_value_give_err("verbosefile", CSTR_AS_OPTVAL(argv[0] + argv_idx), 0);
+          set_option_value_give_err(kOptVerbosefile, CSTR_AS_OPTVAL(argv[0] + argv_idx), 0);
           argv_idx = (int)strlen(argv[0]);
         }
         break;
@@ -1256,7 +1256,7 @@ static void command_line_scan(mparm_T *parmp)
         // "-w {scriptout}" write to script
         if (ascii_isdigit((argv[0])[argv_idx])) {
           n = get_number_arg(argv[0], &argv_idx, 10);
-          set_option_value_give_err("window", NUMBER_OPTVAL((OptInt)n), 0);
+          set_option_value_give_err(kOptWindow, NUMBER_OPTVAL((OptInt)n), 0);
           break;
         }
         want_argument = true;
@@ -1352,7 +1352,7 @@ static void command_line_scan(mparm_T *parmp)
           break;
 
         case 'i':    // "-i {shada}" use for shada
-          set_option_value_give_err("shadafile", CSTR_AS_OPTVAL(argv[0]), 0);
+          set_option_value_give_err(kOptShadafile, CSTR_AS_OPTVAL(argv[0]), 0);
           break;
 
         case 'l':    // "-l" Lua script: args after "-l".
@@ -1362,7 +1362,7 @@ static void command_line_scan(mparm_T *parmp)
           parmp->no_swap_file = true;
           parmp->use_vimrc = parmp->use_vimrc ? parmp->use_vimrc : "NONE";
           if (p_shadafile == NULL || *p_shadafile == NUL) {
-            set_option_value_give_err("shadafile", STATIC_CSTR_AS_OPTVAL("NONE"), 0);
+            set_option_value_give_err(kOptShadafile, STATIC_CSTR_AS_OPTVAL("NONE"), 0);
           }
           parmp->luaf = argv[0];
           argc--;
@@ -1398,7 +1398,7 @@ scripterror:
           if (ascii_isdigit(*(argv[0]))) {
             argv_idx = 0;
             n = get_number_arg(argv[0], &argv_idx, 10);
-            set_option_value_give_err("window", NUMBER_OPTVAL((OptInt)n), 0);
+            set_option_value_give_err(kOptWindow, NUMBER_OPTVAL((OptInt)n), 0);
             argv_idx = -1;
             break;
           }
@@ -1549,7 +1549,7 @@ static void handle_quickfix(mparm_T *paramp)
 {
   if (paramp->edit_type == EDIT_QF) {
     if (paramp->use_ef != NULL) {
-      set_string_option_direct("ef", -1, paramp->use_ef, OPT_FREE, SID_CARG);
+      set_string_option_direct(kOptErrorfile, paramp->use_ef, OPT_FREE, SID_CARG);
     }
     vim_snprintf(IObuff, IOSIZE, "cfile %s", p_ef);
     if (qf_init(NULL, p_ef, p_efm, true, IObuff, p_menc) < 0) {
@@ -1794,7 +1794,7 @@ static void edit_buffers(mparm_T *parmp, char *cwd)
 
           p_shm_save = xstrdup(p_shm);
           snprintf(buf, sizeof(buf), "F%s", p_shm);
-          set_option_value_give_err("shm", CSTR_AS_OPTVAL(buf), 0);
+          set_option_value_give_err(kOptShortmess, CSTR_AS_OPTVAL(buf), 0);
         }
       } else {
         if (curwin->w_next == NULL) {           // just checking
@@ -1839,7 +1839,7 @@ static void edit_buffers(mparm_T *parmp, char *cwd)
   }
 
   if (p_shm_save != NULL) {
-    set_option_value_give_err("shm", CSTR_AS_OPTVAL(p_shm_save), 0);
+    set_option_value_give_err(kOptShortmess, CSTR_AS_OPTVAL(p_shm_save), 0);
     xfree(p_shm_save);
   }
 

src/nvim/memline.c

@@ -974,7 +974,7 @@ void ml_recover(bool checkext)
     set_fileformat(b0_ff - 1, OPT_LOCAL);
   }
   if (b0_fenc != NULL) {
-    set_option_value_give_err("fenc", CSTR_AS_OPTVAL(b0_fenc), OPT_LOCAL);
+    set_option_value_give_err(kOptFileencoding, CSTR_AS_OPTVAL(b0_fenc), OPT_LOCAL);
     xfree(b0_fenc);
   }
   unchanged(curbuf, true, true);

src/nvim/option.h

@@ -87,7 +87,7 @@ typedef enum {
   OPT_SKIPRTP   = 0x100,  ///< "skiprtp" in 'sessionoptions'
 } OptionFlags;
 
-/// Return value from get_option_value_strict
+/// Return value from get_option_attrs().
 enum {
   SOPT_GLOBAL = 0x01,  ///< Option has global value
   SOPT_WIN    = 0x02,  ///< Option has window-local value

src/nvim/option_defs.h

@@ -122,3 +122,8 @@ typedef enum {
   kOptReqWin    = 1,  ///< Request window-local option value
   kOptReqBuf    = 2,  ///< Request buffer-local option value
 } OptReqScope;
+
+#ifdef INCLUDE_GENERATED_DECLARATIONS
+// Initialize the OptIndex enum.
+# include "options_enum.generated.h"
+#endif

src/nvim/optionstr.c

@@ -283,7 +283,7 @@ static void set_string_option_global(vimoption_T *opt, char **varp)
 
 /// Set a string option to a new value (without checking the effect).
 /// The string is copied into allocated memory.
-/// if ("opt_idx" == -1) "name" is used, otherwise "opt_idx" is used.
+/// if ("opt_idx" == kOptInvalid) "name" is used, otherwise "opt_idx" is used.
 /// When "set_sid" is zero set the scriptID to current_sctx.sc_sid.  When
 /// "set_sid" is SID_NONE don't set the scriptID.  Otherwise set the scriptID to
 /// "set_sid".
@@ -291,22 +291,9 @@ static void set_string_option_global(vimoption_T *opt, char **varp)
 /// @param opt_flags  OPT_FREE, OPT_LOCAL and/or OPT_GLOBAL.
 ///
 /// TODO(famiu): Remove this and its win/buf variants.
-void set_string_option_direct(const char *name, int opt_idx, const char *val, int opt_flags,
+void set_string_option_direct(OptIndex opt_idx, const char *val, int opt_flags, int set_sid)
-                              int set_sid)
 {
-  int both = (opt_flags & (OPT_LOCAL | OPT_GLOBAL)) == 0;
+  vimoption_T *opt = get_option(opt_idx);
-  int idx = opt_idx;
-
-  if (idx == -1) {  // Use name.
-    idx = findoption(name);
-    if (idx < 0) {  // Not found (should not happen).
-      internal_error("set_string_option_direct()");
-      siemsg(_("For option %s"), name);
-      return;
-    }
-  }
-
-  vimoption_T *opt = get_option(idx);
 
   if (opt->var == NULL) {  // can't set hidden option
     return;
@@ -314,9 +301,10 @@ void set_string_option_direct(const char *name, int opt_idx, const char *val, in
 
   assert(opt->var != &p_shada);
 
+  int both = (opt_flags & (OPT_LOCAL | OPT_GLOBAL)) == 0;
   char *s = xstrdup(val);
-  {
   char **varp = (char **)get_varp_scope(opt, both ? OPT_LOCAL : opt_flags);
+
   if ((opt_flags & OPT_FREE) && (opt->flags & P_ALLOCED)) {
     free_string_option(*varp);
   }
@@ -345,22 +333,21 @@ void set_string_option_direct(const char *name, int opt_idx, const char *val, in
       script_ctx.sc_seq = 0;
       script_ctx.sc_lnum = 0;
     }
-      set_option_sctx_idx(idx, opt_flags, script_ctx);
+    set_option_sctx(opt_idx, opt_flags, script_ctx);
-    }
   }
 }
 
 /// Like set_string_option_direct(), but for a window-local option in "wp".
 /// Blocks autocommands to avoid the old curwin becoming invalid.
-void set_string_option_direct_in_win(win_T *wp, const char *name, int opt_idx, const char *val,
+void set_string_option_direct_in_win(win_T *wp, OptIndex opt_idx, const char *val, int opt_flags,
-                                     int opt_flags, int set_sid)
+                                     int set_sid)
 {
   win_T *save_curwin = curwin;
 
   block_autocmds();
   curwin = wp;
   curbuf = curwin->w_buffer;
-  set_string_option_direct(name, opt_idx, val, opt_flags, set_sid);
+  set_string_option_direct(opt_idx, val, opt_flags, set_sid);
   curwin = save_curwin;
   curbuf = curwin->w_buffer;
   unblock_autocmds();
@@ -368,14 +355,14 @@ void set_string_option_direct_in_win(win_T *wp, const char *name, int opt_idx, c
 
 /// Like set_string_option_direct(), but for a buffer-local option in "buf".
 /// Blocks autocommands to avoid the old curwin becoming invalid.
-void set_string_option_direct_in_buf(buf_T *buf, const char *name, int opt_idx, const char *val,
+void set_string_option_direct_in_buf(buf_T *buf, OptIndex opt_idx, const char *val, int opt_flags,
-                                     int opt_flags, int set_sid)
+                                     int set_sid)
 {
   buf_T *save_curbuf = curbuf;
 
   block_autocmds();
   curbuf = buf;
-  set_string_option_direct(name, opt_idx, val, opt_flags, set_sid);
+  set_string_option_direct(opt_idx, val, opt_flags, set_sid);
   curbuf = save_curbuf;
   unblock_autocmds();
 }

src/nvim/path.c

@@ -1666,7 +1666,7 @@ static char *eval_includeexpr(const char *const ptr, const size_t len)
   current_sctx = curbuf->b_p_script_ctx[BV_INEX].script_ctx;
 
   char *res = eval_to_string_safe(curbuf->b_p_inex,
-                                  was_set_insecurely(curwin, "includeexpr", OPT_LOCAL));
+                                  was_set_insecurely(curwin, kOptIncludeexpr, OPT_LOCAL));
 
   set_vim_var_string(VV_FNAME, NULL, 0);
   current_sctx = save_sctx;

src/nvim/popupmenu.c

@@ -767,11 +767,11 @@ static bool pum_set_selected(int n, int repeat)
           if (res == OK) {
             // Edit a new, empty buffer. Set options for a "wipeout"
             // buffer.
-            set_option_value_give_err("swf", BOOLEAN_OPTVAL(false), OPT_LOCAL);
+            set_option_value_give_err(kOptSwapfile, BOOLEAN_OPTVAL(false), OPT_LOCAL);
-            set_option_value_give_err("bl", BOOLEAN_OPTVAL(false), OPT_LOCAL);
+            set_option_value_give_err(kOptBuflisted, BOOLEAN_OPTVAL(false), OPT_LOCAL);
-            set_option_value_give_err("bt", STATIC_CSTR_AS_OPTVAL("nofile"), OPT_LOCAL);
+            set_option_value_give_err(kOptBuftype, STATIC_CSTR_AS_OPTVAL("nofile"), OPT_LOCAL);
-            set_option_value_give_err("bh", STATIC_CSTR_AS_OPTVAL("wipe"), OPT_LOCAL);
+            set_option_value_give_err(kOptBufhidden, STATIC_CSTR_AS_OPTVAL("wipe"), OPT_LOCAL);
-            set_option_value_give_err("diff", BOOLEAN_OPTVAL(false), OPT_LOCAL);
+            set_option_value_give_err(kOptDiff, BOOLEAN_OPTVAL(false), OPT_LOCAL);
           }
         }
 

src/nvim/quickfix.c

@@ -3645,12 +3645,12 @@ static int qf_goto_cwindow(const qf_info_T *qi, bool resize, int sz, bool vertsp
 static void qf_set_cwindow_options(void)
 {
   // switch off 'swapfile'
-  set_option_value_give_err("swf", BOOLEAN_OPTVAL(false), OPT_LOCAL);
+  set_option_value_give_err(kOptSwapfile, BOOLEAN_OPTVAL(false), OPT_LOCAL);
-  set_option_value_give_err("bt", STATIC_CSTR_AS_OPTVAL("quickfix"), OPT_LOCAL);
+  set_option_value_give_err(kOptBuftype, STATIC_CSTR_AS_OPTVAL("quickfix"), OPT_LOCAL);
-  set_option_value_give_err("bh", STATIC_CSTR_AS_OPTVAL("hide"), OPT_LOCAL);
+  set_option_value_give_err(kOptBufhidden, STATIC_CSTR_AS_OPTVAL("hide"), OPT_LOCAL);
   RESET_BINDING(curwin);
   curwin->w_p_diff = false;
-  set_option_value_give_err("fdm", STATIC_CSTR_AS_OPTVAL("manual"), OPT_LOCAL);
+  set_option_value_give_err(kOptFoldmethod, STATIC_CSTR_AS_OPTVAL("manual"), OPT_LOCAL);
 }
 
 // Open a new quickfix or location list window, load the quickfix buffer and
@@ -4212,7 +4212,7 @@ static void qf_fill_buffer(qf_list_T *qfl, buf_T *buf, qfline_T *old_last, int q
     // resembles reading a file into a buffer, it's more logical when using
     // autocommands.
     curbuf->b_ro_locked++;
-    set_option_value_give_err("ft", STATIC_CSTR_AS_OPTVAL("qf"), OPT_LOCAL);
+    set_option_value_give_err(kOptFiletype, STATIC_CSTR_AS_OPTVAL("qf"), OPT_LOCAL);
     curbuf->b_p_ma = false;
 
     keep_filetype = true;                 // don't detect 'filetype'
@@ -5090,7 +5090,7 @@ void ex_cfile(exarg_T *eap)
     }
   }
   if (*eap->arg != NUL) {
-    set_string_option_direct("ef", -1, eap->arg, OPT_FREE, 0);
+    set_string_option_direct(kOptErrorfile, eap->arg, OPT_FREE, 0);
   }
 
   char *enc = (*curbuf->b_p_menc != NUL) ? curbuf->b_p_menc : p_menc;
@@ -7220,7 +7220,7 @@ void ex_helpgrep(exarg_T *eap)
   bool updated = false;
   // Make 'cpoptions' empty, the 'l' flag should not be used here.
   char *const save_cpo = p_cpo;
-  const bool save_cpo_allocated = is_option_allocated("cpo");
+  const bool save_cpo_allocated = (get_option(kOptCpoptions)->flags & P_ALLOCED);
   p_cpo = empty_string_option;
 
   bool new_qi = false;
@@ -7258,7 +7258,7 @@ void ex_helpgrep(exarg_T *eap)
     // Darn, some plugin changed the value.  If it's still empty it was
     // changed and restored, need to restore in the complicated way.
     if (*p_cpo == NUL) {
-      set_option_value_give_err("cpo", CSTR_AS_OPTVAL(save_cpo), 0);
+      set_option_value_give_err(kOptCpoptions, CSTR_AS_OPTVAL(save_cpo), 0);
     }
     if (save_cpo_allocated) {
       free_string_option(save_cpo);

src/nvim/runtime.c

@@ -1061,7 +1061,7 @@ static int add_pack_dir_to_rtp(char *fname, bool is_pack)
     xstrlcat(new_rtp, afterdir, new_rtp_capacity);
   }
 
-  set_option_value_give_err("rtp", CSTR_AS_OPTVAL(new_rtp), 0);
+  set_option_value_give_err(kOptRuntimepath, CSTR_AS_OPTVAL(new_rtp), 0);
   xfree(new_rtp);
   retval = OK;
 

src/nvim/spell.c

@@ -3218,14 +3218,14 @@ void ex_spelldump(exarg_T *eap)
   if (no_spell_checking(curwin)) {
     return;
   }
-  OptVal spl = get_option_value(findoption("spl"), OPT_LOCAL);
+  OptVal spl = get_option_value(kOptSpelllang, OPT_LOCAL);
 
   // Create a new empty buffer in a new window.
   do_cmdline_cmd("new");
 
   // enable spelling locally in the new window
-  set_option_value_give_err("spell", BOOLEAN_OPTVAL(true), OPT_LOCAL);
+  set_option_value_give_err(kOptSpell, BOOLEAN_OPTVAL(true), OPT_LOCAL);
-  set_option_value_give_err("spl", spl, OPT_LOCAL);
+  set_option_value_give_err(kOptSpelllang, spl, OPT_LOCAL);
   optval_free(spl);
 
   if (!buf_is_empty(curbuf)) {

src/nvim/spellfile.c

@@ -5600,7 +5600,7 @@ static void init_spellfile(void)
                      && strstr(path_tail(fname), ".ascii.") != NULL)
                     ? "ascii"
                     : spell_enc()));
-      set_option_value_give_err("spellfile", CSTR_AS_OPTVAL(buf), OPT_LOCAL);
+      set_option_value_give_err(kOptSpellfile, CSTR_AS_OPTVAL(buf), OPT_LOCAL);
       break;
     }
     aspath = false;

src/nvim/statusline.c

@@ -296,7 +296,7 @@ static void win_redr_custom(win_T *wp, bool draw_winbar, bool draw_ruler)
   char buf[MAXPATHL];
   char transbuf[MAXPATHL];
   char *stl;
-  char *opt_name;
+  OptIndex opt_idx = kOptInvalid;
   int opt_scope = 0;
   stl_hlrec_t *hltab;
   StlClickRecord *tabtab;
@@ -320,9 +320,9 @@ static void win_redr_custom(win_T *wp, bool draw_winbar, bool draw_ruler)
     fillchar = ' ';
     attr = HL_ATTR(HLF_TPF);
     maxwidth = Columns;
-    opt_name = "tabline";
+    opt_idx = kOptTabline;
   } else if (draw_winbar) {
-    opt_name = "winbar";
+    opt_idx = kOptWinbar;
     stl = ((*wp->w_p_wbr != NUL) ? wp->w_p_wbr : p_wbr);
     opt_scope = ((*wp->w_p_wbr != NUL) ? OPT_LOCAL : 0);
     row = -1;  // row zero is first row of text
@@ -351,7 +351,7 @@ static void win_redr_custom(win_T *wp, bool draw_winbar, bool draw_ruler)
 
     if (draw_ruler) {
       stl = p_ruf;
-      opt_name = "rulerformat";
+      opt_idx = kOptRulerformat;
       // advance past any leading group spec - implicit in ru_col
       if (*stl == '%') {
         if (*++stl == '-') {
@@ -379,7 +379,7 @@ static void win_redr_custom(win_T *wp, bool draw_winbar, bool draw_ruler)
         attr = HL_ATTR(HLF_MSG);
       }
     } else {
-      opt_name = "statusline";
+      opt_idx = kOptStatusline;
       stl = ((*wp->w_p_stl != NUL) ? wp->w_p_stl : p_stl);
       opt_scope = ((*wp->w_p_stl != NUL) ? OPT_LOCAL : 0);
     }
@@ -402,7 +402,7 @@ static void win_redr_custom(win_T *wp, bool draw_winbar, bool draw_ruler)
   // Make a copy, because the statusline may include a function call that
   // might change the option value and free the memory.
   stl = xstrdup(stl);
-  build_stl_str_hl(ewp, buf, sizeof(buf), stl, opt_name, opt_scope,
+  build_stl_str_hl(ewp, buf, sizeof(buf), stl, opt_idx, opt_scope,
                    fillchar, maxwidth, &hltab, &tabtab, NULL);
 
   xfree(stl);
@@ -881,7 +881,7 @@ int build_statuscol_str(win_T *wp, linenr_T lnum, linenr_T relnum, statuscol_T *
 
   StlClickRecord *clickrec;
   char *stc = xstrdup(wp->w_p_stc);
-  int width = build_stl_str_hl(wp, stcp->text, MAXPATHL, stc, "statuscolumn", OPT_LOCAL, ' ',
+  int width = build_stl_str_hl(wp, stcp->text, MAXPATHL, stc, kOptStatuscolumn, OPT_LOCAL, ' ',
                                stcp->width, &stcp->hlrec, fillclick ? &clickrec : NULL, stcp);
   xfree(stc);
 
@@ -913,8 +913,8 @@ int build_statuscol_str(win_T *wp, linenr_T lnum, linenr_T relnum, statuscol_T *
 ///             Note: This should not be NameBuff
 /// @param outlen  The length of the output buffer
 /// @param fmt  The statusline format string
-/// @param opt_name  The option name corresponding to "fmt"
+/// @param opt_idx  Index of the option corresponding to "fmt"
-/// @param opt_scope  The scope corresponding to "opt_name"
+/// @param opt_scope  The scope corresponding to "opt_idx"
 /// @param fillchar  Character to use when filling empty space in the statusline
 /// @param maxwidth  The maximum width to make the statusline
 /// @param hltab  HL attributes (can be NULL)
@@ -922,9 +922,9 @@ int build_statuscol_str(win_T *wp, linenr_T lnum, linenr_T relnum, statuscol_T *
 /// @param stcp  Status column attributes (can be NULL)
 ///
 /// @return  The final width of the statusline
-int build_stl_str_hl(win_T *wp, char *out, size_t outlen, char *fmt, char *opt_name, int opt_scope,
+int build_stl_str_hl(win_T *wp, char *out, size_t outlen, char *fmt, OptIndex opt_idx,
-                     int fillchar, int maxwidth, stl_hlrec_t **hltab, StlClickRecord **tabtab,
+                     int opt_scope, int fillchar, int maxwidth, stl_hlrec_t **hltab,
-                     statuscol_T *stcp)
+                     StlClickRecord **tabtab, statuscol_T *stcp)
 {
   static size_t stl_items_len = 20;  // Initial value, grows as needed.
   static stl_item_t *stl_items = NULL;
@@ -957,9 +957,9 @@ int build_stl_str_hl(win_T *wp, char *out, size_t outlen, char *fmt, char *opt_n
     stl_separator_locations = xmalloc(sizeof(int) * stl_items_len);
   }
 
-  // if "fmt" was set insecurely it needs to be evaluated in the sandbox
+  // If "fmt" was set insecurely it needs to be evaluated in the sandbox.
-  // "opt_name" will be NULL when caller is nvim_eval_statusline()
+  // "opt_idx" will be kOptInvalid when caller is nvim_eval_statusline().
-  const int use_sandbox = opt_name ? was_set_insecurely(wp, opt_name, opt_scope)
+  const int use_sandbox = (opt_idx != kOptInvalid) ? was_set_insecurely(wp, opt_idx, opt_scope)
                                                    : false;
 
   // When the format starts with "%!" then evaluate it as an expression and
@@ -1545,7 +1545,7 @@ int build_stl_str_hl(win_T *wp, char *out, size_t outlen, char *fmt, char *opt_n
       break;
 
     case STL_SHOWCMD:
-      if (p_sc && (opt_name == NULL || strcmp(opt_name, p_sloc) == 0)) {
+      if (p_sc && (opt_idx == kOptInvalid || findoption(p_sloc) == opt_idx)) {
         str = showcmd_buf;
       }
       break;
@@ -2177,8 +2177,8 @@ int build_stl_str_hl(win_T *wp, char *out, size_t outlen, char *fmt, char *opt_n
   // TODO(Bram): find out why using called_emsg_before makes tests fail, does it
   // matter?
   // if (called_emsg > called_emsg_before)
-  if (opt_name && did_emsg > did_emsg_before) {
+  if (opt_idx != kOptInvalid && did_emsg > did_emsg_before) {
-    set_string_option_direct(opt_name, -1, "", OPT_FREE | opt_scope, SID_ERROR);
+    set_string_option_direct(opt_idx, "", OPT_FREE | opt_scope, SID_ERROR);
   }
 
   // A user function may reset KeyTyped, restore it.

src/nvim/statusline.h

@@ -4,6 +4,7 @@
 
 #include "nvim/buffer_defs.h"  // IWYU pragma: keep
 #include "nvim/macros_defs.h"
+#include "nvim/option_defs.h"
 #include "nvim/statusline_defs.h"  // IWYU pragma: export
 
 /// Array defining what should be done when tabline is clicked

src/nvim/terminal.c

@@ -233,7 +233,7 @@ void terminal_open(Terminal **termpp, buf_T *buf, TerminalOptions opts)
   aucmd_prepbuf(&aco, buf);
 
   refresh_screen(rv, buf);
-  set_option_value("buftype", STATIC_CSTR_AS_OPTVAL("terminal"), OPT_LOCAL);
+  set_option_value(kOptBuftype, STATIC_CSTR_AS_OPTVAL("terminal"), OPT_LOCAL);
 
   // Default settings for terminal buffers
   buf->b_p_ma = false;     // 'nomodifiable'
@@ -241,8 +241,8 @@ void terminal_open(Terminal **termpp, buf_T *buf, TerminalOptions opts)
   buf->b_p_scbk =          // 'scrollback' (initialize local from global)
                   (p_scbk < 0) ? 10000 : MAX(1, p_scbk);
   buf->b_p_tw = 0;         // 'textwidth'
-  set_option_value("wrap", BOOLEAN_OPTVAL(false), OPT_LOCAL);
+  set_option_value(kOptWrap, BOOLEAN_OPTVAL(false), OPT_LOCAL);
-  set_option_value("list", BOOLEAN_OPTVAL(false), OPT_LOCAL);
+  set_option_value(kOptList, BOOLEAN_OPTVAL(false), OPT_LOCAL);
   if (buf->b_ffname != NULL) {
     buf_set_term_title(buf, buf->b_ffname, strlen(buf->b_ffname));
   }

src/nvim/textformat.c

@@ -870,7 +870,7 @@ void op_formatexpr(oparg_T *oap)
 /// @param c  character to be inserted
 int fex_format(linenr_T lnum, long count, int c)
 {
-  int use_sandbox = was_set_insecurely(curwin, "formatexpr", OPT_LOCAL);
+  int use_sandbox = was_set_insecurely(curwin, kOptFormatexpr, OPT_LOCAL);
   const sctx_T save_sctx = current_sctx;
 
   // Set v:lnum to the first line number and v:count to the number of lines.

src/nvim/ui.c

@@ -235,7 +235,7 @@ void ui_refresh(void)
   p_lz = save_p_lz;
 
   if (ext_widgets[kUIMessages]) {
-    set_option_value("cmdheight", NUMBER_OPTVAL(0), 0);
+    set_option_value(kOptCmdheight, NUMBER_OPTVAL(0), 0);
     command_height();
   }
   ui_mode_info_set();

src/nvim/window.c

@@ -5183,7 +5183,7 @@ void win_new_screensize(void)
   if (old_Rows != Rows) {
     // If 'window' uses the whole screen, keep it using that.
     // Don't change it when set with "-w size" on the command line.
-    if (p_window == old_Rows - 1 || (old_Rows == 0 && !option_was_set("window"))) {
+    if (p_window == old_Rows - 1 || (old_Rows == 0 && !option_was_set(kOptWindow))) {
       p_window = Rows - 1;
     }
     old_Rows = Rows;

test/functional/lua/ffi_spec.lua

@@ -38,7 +38,7 @@ describe('ffi.cdef', function()
           char *out,
           size_t outlen,
           char *fmt,
-          char *opt_name,
+          int opt_idx,
           int opt_scope,
           int fillchar,
           int maxwidth,
@@ -53,7 +53,7 @@ describe('ffi.cdef', function()
         ffi.new('char[1024]'),
         1024,
         ffi.cast('char*', 'StatusLineOfLength20'),
-        nil,
+        -1,
         0,
         0,
         0,

test/unit/statusline_spec.lua

@@ -33,7 +33,7 @@ describe('build_stl_str_hl', function()
       output_buffer,
       buffer_byte_size,
       to_cstr(pat),
-      NULL,
+      -1,
       0,
       fillchar,
       maximum_cell_count,