refactor(options): remove `getoption_T` and introduce `OptVal` (#23850)

Removes the `getoption_T` struct and also introduces the `OptVal` struct
to unify the methods of getting/setting different option value types.
This is the first of many PRs to reduce code duplication in the Vim
option code as well as to make options easier to maintain. It also
increases the flexibility and extensibility of options. Which opens the
door for things like Array and Dictionary options.

1 files changed, 179 insertions, 99 deletions

diff --git a/src/nvim/api/options.c b/src/nvim/api/options.c
index e18312a6dc..ed13e51e90 100644
--- a/src/nvim/api/options.c
+++ b/src/nvim/api/options.c
@@ -113,10 +113,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", 0L, "hide", OPT_LOCAL);
-    set_option_value("buftype", 0L, "nofile", OPT_LOCAL);
-    set_option_value("swapfile", 0L, NULL, OPT_LOCAL);
-    set_option_value("modeline", 0L, NULL, OPT_LOCAL);  // 'nomodeline'
+    set_option_value("bufhidden", STATIC_CSTR_AS_OPTVAL("hide"), OPT_LOCAL);
+    set_option_value("buftype", STATIC_CSTR_AS_OPTVAL("nofile"), OPT_LOCAL);
+    set_option_value("swapfile", BOOLEAN_OPTVAL(false), OPT_LOCAL);
+    set_option_value("modeline", BOOLEAN_OPTVAL(false), OPT_LOCAL);  // 'nomodeline'
 
     ftbuf->b_p_ft = xstrdup(filetype);
     do_filetype_autocmd(ftbuf, false);
@@ -125,6 +125,54 @@ static buf_T *do_ft_buf(char *filetype, aco_save_T *aco, Error *err)
   return ftbuf;
 }
 
+/// Consume an OptVal and convert it to an API Object.
+static Object optval_as_object(OptVal o)
+{
+  switch (o.type) {
+  case kOptValTypeNil:
+    return NIL;
+  case kOptValTypeBoolean:
+    switch (o.data.boolean) {
+    case kFalse:
+    case kTrue:
+      return BOOLEAN_OBJ(o.data.boolean);
+    case kNone:
+      return NIL;
+    default:
+      abort();
+    }
+  case kOptValTypeNumber:
+    return INTEGER_OBJ(o.data.number);
+  case kOptValTypeString:
+    return STRING_OBJ(o.data.string);
+  default:
+    abort();
+  }
+}
+
+/// Consume an API Object and convert it to an OptVal.
+static OptVal object_as_optval(Object o, Error *err)
+{
+  switch (o.type) {
+  case kObjectTypeNil:
+    return NIL_OPTVAL;
+    break;
+  case kObjectTypeBoolean:
+    return BOOLEAN_OPTVAL(o.data.boolean);
+    break;
+  case kObjectTypeInteger:
+    return NUMBER_OPTVAL(o.data.integer);
+    break;
+  case kObjectTypeString:
+    return STRING_OPTVAL(o.data.string);
+    break;
+  default:
+    // Some Object types don't have an OptVal equivalent. Error out in those cases.
+    api_set_error(err, kErrorTypeException, "Invalid option value");
+    return NIL_OPTVAL;
+  }
+}
+
 /// Gets the value of an option. The behavior of this function matches that of
 /// |:set|: the local value of an option is returned if it exists; otherwise,
 /// the global value is returned. Local values always correspond to the current
@@ -147,6 +195,7 @@ Object nvim_get_option_value(String name, Dict(option) *opts, Error *err)
   FUNC_API_SINCE(9)
 {
   Object rv = OBJECT_INIT;
+  OptVal value = NIL_OPTVAL;
 
   int scope = 0;
   int opt_type = SREQ_GLOBAL;
@@ -154,14 +203,14 @@ Object nvim_get_option_value(String name, Dict(option) *opts, Error *err)
   char *filetype = NULL;
 
   if (!validate_option_value_args(opts, &scope, &opt_type, &from, &filetype, err)) {
-    return rv;
+    goto err;
   }
 
   aco_save_T aco;
 
   buf_T *ftbuf = do_ft_buf(filetype, &aco, err);
   if (ERROR_SET(err)) {
-    return rv;
+    goto err;
   }
 
   if (ftbuf != NULL) {
@@ -169,10 +218,8 @@ Object nvim_get_option_value(String name, Dict(option) *opts, Error *err)
     from = ftbuf;
   }
 
-  long numval = 0;
-  char *stringval = NULL;
-  getoption_T result = access_option_value_for(name.data, &numval, &stringval, scope, opt_type,
-                                               from, true, err);
+  bool hidden;
+  value = get_option_value_for(name.data, NULL, scope, &hidden, opt_type, from, err);
 
   if (ftbuf != NULL) {
     // restore curwin/curbuf and a few other things
@@ -183,35 +230,16 @@ Object nvim_get_option_value(String name, Dict(option) *opts, Error *err)
   }
 
   if (ERROR_SET(err)) {
-    return rv;
+    goto err;
   }
 
-  switch (result) {
-  case gov_string:
-    rv = CSTR_AS_OBJ(stringval);
-    break;
-  case gov_number:
-    rv = INTEGER_OBJ(numval);
-    break;
-  case gov_bool:
-    switch (numval) {
-    case 0:
-    case 1:
-      rv = BOOLEAN_OBJ(numval);
-      break;
-    default:
-      // Boolean options that return something other than 0 or 1 should return nil. Currently this
-      // only applies to 'autoread' which uses -1 as a local value to indicate "unset"
-      rv = NIL;
-      break;
-    }
-    break;
-  default:
-    VALIDATE_S(false, "option", name.data, {
-      return rv;
-    });
-  }
+  VALIDATE_S(!hidden && value.type != kOptValTypeNil, "option", name.data, {
+    goto err;
+  });
 
+  return optval_as_object(value);
+err:
+  optval_free(value);
   return rv;
 }
 
@@ -253,30 +281,19 @@ void nvim_set_option_value(uint64_t channel_id, String name, Object value, Dict(
     }
   }
 
-  long numval = 0;
-  char *stringval = NULL;
+  OptVal optval = object_as_optval(value, err);
+
+  // Handle invalid option value type.
+  if (ERROR_SET(err)) {
+    api_clear_error(err);
 
-  switch (value.type) {
-  case kObjectTypeInteger:
-    numval = (long)value.data.integer;
-    break;
-  case kObjectTypeBoolean:
-    numval = value.data.boolean ? 1 : 0;
-    break;
-  case kObjectTypeString:
-    stringval = value.data.string.data;
-    break;
-  case kObjectTypeNil:
-    scope |= OPT_CLEAR;
-    break;
-  default:
     VALIDATE_EXP(false, name.data, "Integer/Boolean/String", api_typename(value.type), {
       return;
     });
   }
 
   WITH_SCRIPT_CONTEXT(channel_id, {
-    access_option_value_for(name.data, &numval, &stringval, scope, opt_type, to, false, err);
+    set_option_value_for(name.data, optval, scope, opt_type, to, err);
   });
 }
 
@@ -341,72 +358,135 @@ Dictionary nvim_get_option_info2(String name, Dict(option) *opts, Error *err)
   return get_vimoption(name, scope, buf, win, err);
 }
 
-static getoption_T access_option_value(char *key, long *numval, char **stringval, int opt_flags,
-                                       bool get, Error *err)
+/// Switch current context to get/set option value for window/buffer.
+///
+/// @param[out]  ctx       Current context. switchwin_T for window and aco_save_T for buffer.
+/// @param[in]   opt_type  Option type. See SREQ_* in option_defs.h.
+/// @param[in]   from      Target buffer/window.
+/// @param[out]  err       Error message, if any.
+///
+/// @return  true if context was switched, false otherwise.
+static bool switch_option_context(void *const ctx, int opt_type, void *const from, Error *err)
 {
-  if (get) {
-    return get_option_value(key, numval, stringval, NULL, opt_flags);
-  } else {
-    const char *errmsg;
-    if ((errmsg = set_option_value(key, *numval, *stringval, opt_flags))) {
+  switch (opt_type) {
+  case SREQ_WIN: {
+    win_T *const win = (win_T *)from;
+    switchwin_T *const switchwin = (switchwin_T *)ctx;
+
+    if (win == curwin) {
+      return false;
+    }
+
+    if (switch_win_noblock(switchwin, win, win_find_tabpage(win), true)
+        == FAIL) {
+      restore_win_noblock(switchwin, true);
+
       if (try_end(err)) {
-        return 0;
+        return false;
       }
+      api_set_error(err, kErrorTypeException, "Problem while switching windows");
+      return false;
+    }
+    return true;
+  }
+  case SREQ_BUF: {
+    buf_T *const buf = (buf_T *)from;
+    aco_save_T *const aco = (aco_save_T *)ctx;
 
-      api_set_error(err, kErrorTypeException, "%s", errmsg);
+    if (buf == curbuf) {
+      return false;
     }
-    return 0;
+    aucmd_prepbuf(aco, buf);
+    return true;
+  }
+  case SREQ_GLOBAL:
+    return false;
+  default:
+    abort();  // This should never happen.
   }
 }
 
-getoption_T access_option_value_for(char *key, long *numval, char **stringval, int opt_flags,
-                                    int opt_type, void *from, bool get, Error *err)
+/// Restore context after getting/setting option for window/buffer. See switch_option_context() for
+/// params.
+static void restore_option_context(void *const ctx, const int opt_type)
 {
-  bool need_switch = false;
-  switchwin_T switchwin;
-  aco_save_T aco;
-  getoption_T result = 0;
-
-  try_start();
   switch (opt_type) {
   case SREQ_WIN:
-    need_switch = (win_T *)from != curwin;
-    if (need_switch) {
-      if (switch_win_noblock(&switchwin, (win_T *)from, win_find_tabpage((win_T *)from), true)
-          == FAIL) {
-        restore_win_noblock(&switchwin, true);
-        if (try_end(err)) {
-          return result;
-        }
-        api_set_error(err, kErrorTypeException, "Problem while switching windows");
-        return result;
-      }
-    }
-    result = access_option_value(key, numval, stringval, opt_flags, get, err);
-    if (need_switch) {
-      restore_win_noblock(&switchwin, true);
-    }
+    restore_win_noblock((switchwin_T *)ctx, true);
     break;
   case SREQ_BUF:
-    need_switch = (buf_T *)from != curbuf;
-    if (need_switch) {
-      aucmd_prepbuf(&aco, (buf_T *)from);
-    }
-    result = access_option_value(key, numval, stringval, opt_flags, get, err);
-    if (need_switch) {
-      aucmd_restbuf(&aco);
-    }
+    aucmd_restbuf((aco_save_T *)ctx);
     break;
   case SREQ_GLOBAL:
-    result = access_option_value(key, numval, stringval, opt_flags, get, err);
     break;
+  default:
+    abort();  // This should never happen.
+  }
+}
+
+/// Get option value for buffer / window.
+///
+/// @param[in]   name      Option name.
+/// @param[out]  flagsp    Set to the option flags (P_xxxx) (if not NULL).
+/// @param[in]   scope     Option scope (can be OPT_LOCAL, OPT_GLOBAL or a combination).
+/// @param[out]  hidden    Whether option is hidden.
+/// @param[in]   opt_type  Option type. See SREQ_* in option_defs.h.
+/// @param[in]   from      Target buffer/window.
+/// @param[out]  err       Error message, if any.
+///
+/// @return  Option value. Must be freed by caller.
+OptVal get_option_value_for(const char *const name, uint32_t *flagsp, int scope, bool *hidden,
+                            const int opt_type, void *const from, Error *err)
+{
+  switchwin_T switchwin;
+  aco_save_T aco;
+  void *ctx = opt_type == SREQ_WIN ? (void *)&switchwin
+                                   : (opt_type == SREQ_BUF ? (void *)&aco : NULL);
+
+  bool switched = switch_option_context(ctx, opt_type, from, err);
+  if (ERROR_SET(err)) {
+    return NIL_OPTVAL;
+  }
+
+  OptVal retv = get_option_value(name, flagsp, scope, hidden);
+
+  if (switched) {
+    restore_option_context(ctx, opt_type);
   }
 
+  return retv;
+}
+
+/// Set option value for buffer / window.
+///
+/// @param[in]   name       Option name.
+/// @param[in]   value      Option value.
+/// @param[in]   opt_flags  Flags: OPT_LOCAL, OPT_GLOBAL, or 0 (both).
+///                         If OPT_CLEAR is set, the value of the option
+///                         is cleared  (the exact semantics of this depend
+///                         on the option).
+/// @param[in]   opt_type   Option type. See SREQ_* in option_defs.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,
+                          const int opt_type, void *const from, Error *err)
+{
+  switchwin_T switchwin;
+  aco_save_T aco;
+  void *ctx = opt_type == SREQ_WIN ? (void *)&switchwin
+                                   : (opt_type == SREQ_BUF ? (void *)&aco : NULL);
+
+  bool switched = switch_option_context(ctx, opt_type, from, err);
   if (ERROR_SET(err)) {
-    return result;
+    return;
   }
 
-  try_end(err);
+  const char *const errmsg = set_option_value(name, value, opt_flags);
+  if (errmsg) {
+    api_set_error(err, kErrorTypeException, "%s", errmsg);
+  }
 
-  return result;
+  if (switched) {
+    restore_option_context(ctx, opt_type);
+  }
 }