api: Do not truncate errors <1 MB. #6237

Closes #5984

13 files changed, 197 insertions, 168 deletions

diff --git a/src/nvim/api/buffer.c b/src/nvim/api/buffer.c
index 1b3592679b..2f306ebfc8 100644
--- a/src/nvim/api/buffer.c
+++ b/src/nvim/api/buffer.c
@@ -171,7 +171,7 @@ ArrayOf(String) nvim_buf_get_lines(uint64_t channel_id,
   end = normalize_index(buf, end, &oob);
 
   if (strict_indexing && oob) {
-    api_set_error(err, Validation, _("Index out of bounds"));
+    _api_set_error(err, kErrorTypeValidation, _("Index out of bounds"));
     return rv;
   }
 
@@ -187,7 +187,7 @@ ArrayOf(String) nvim_buf_get_lines(uint64_t channel_id,
     int64_t lnum = start + (int64_t)i;
 
     if (lnum > LONG_MAX) {
-      api_set_error(err, Validation, _("Line index is too high"));
+      _api_set_error(err, kErrorTypeValidation, _("Line index is too high"));
       goto end;
     }
 
@@ -283,14 +283,14 @@ void nvim_buf_set_lines(uint64_t channel_id,
   end = normalize_index(buf, end, &oob);
 
   if (strict_indexing && oob) {
-    api_set_error(err, Validation, _("Index out of bounds"));
+    _api_set_error(err, kErrorTypeValidation, _("Index out of bounds"));
     return;
   }
 
 
   if (start > end) {
-    api_set_error(err,
-                  Validation,
+    _api_set_error(err,
+                  kErrorTypeValidation,
                   _("Argument \"start\" is higher than \"end\""));
     return;
   }
@@ -304,8 +304,8 @@ void nvim_buf_set_lines(uint64_t channel_id,
 
   for (size_t i = 0; i < new_len; i++) {
     if (replacement.items[i].type != kObjectTypeString) {
-      api_set_error(err,
-                    Validation,
+      _api_set_error(err,
+                    kErrorTypeValidation,
                     _("All items in the replacement array must be strings"));
       goto end;
     }
@@ -317,7 +317,7 @@ void nvim_buf_set_lines(uint64_t channel_id,
     lines[i] = xmallocz(l.size);
     for (size_t j = 0; j < l.size; j++) {
       if (l.data[j] == '\n' && channel_id != INTERNAL_CALL) {
-        api_set_error(err, Exception, _("string cannot contain newlines"));
+        _api_set_error(err, kErrorTypeException, _("string cannot contain newlines"));
         new_len = i + 1;
         goto end;
       }
@@ -330,7 +330,7 @@ void nvim_buf_set_lines(uint64_t channel_id,
   switch_to_win_for_buf(buf, &save_curwin, &save_curtab, &save_curbuf);
 
   if (u_save((linenr_T)(start - 1), (linenr_T)end) == FAIL) {
-    api_set_error(err, Exception, _("Failed to save undo information"));
+    _api_set_error(err, kErrorTypeException, _("Failed to save undo information"));
     goto end;
   }
 
@@ -340,7 +340,7 @@ void nvim_buf_set_lines(uint64_t channel_id,
   size_t to_delete = (new_len < old_len) ? (size_t)(old_len - new_len) : 0;
   for (size_t i = 0; i < to_delete; i++) {
     if (ml_delete((linenr_T)start, false) == FAIL) {
-      api_set_error(err, Exception, _("Failed to delete line"));
+      _api_set_error(err, kErrorTypeException, _("Failed to delete line"));
       goto end;
     }
   }
@@ -357,12 +357,12 @@ void nvim_buf_set_lines(uint64_t channel_id,
     int64_t lnum = start + (int64_t)i;
 
     if (lnum > LONG_MAX) {
-      api_set_error(err, Validation, _("Index value is too high"));
+      _api_set_error(err, kErrorTypeValidation, _("Index value is too high"));
       goto end;
     }
 
     if (ml_replace((linenr_T)lnum, (char_u *)lines[i], false) == FAIL) {
-      api_set_error(err, Exception, _("Failed to replace line"));
+      _api_set_error(err, kErrorTypeException, _("Failed to replace line"));
       goto end;
     }
     // Mark lines that haven't been passed to the buffer as they need
@@ -375,12 +375,12 @@ void nvim_buf_set_lines(uint64_t channel_id,
     int64_t lnum = start + (int64_t)i - 1;
 
     if (lnum > LONG_MAX) {
-      api_set_error(err, Validation, _("Index value is too high"));
+      _api_set_error(err, kErrorTypeValidation, _("Index value is too high"));
       goto end;
     }
 
     if (ml_append((linenr_T)lnum, (char_u *)lines[i], 0, false) == FAIL) {
-      api_set_error(err, Exception, _("Failed to insert line"));
+      _api_set_error(err, kErrorTypeException, _("Failed to insert line"));
       goto end;
     }
 
@@ -627,7 +627,7 @@ void nvim_buf_set_name(Buffer buffer, String name, Error *err)
   }
 
   if (ren_ret == FAIL) {
-    api_set_error(err, Exception, _("Failed to rename buffer"));
+    _api_set_error(err, kErrorTypeException, _("Failed to rename buffer"));
   }
 }
 
@@ -639,7 +639,9 @@ Boolean nvim_buf_is_valid(Buffer buffer)
     FUNC_API_SINCE(1)
 {
   Error stub = ERROR_INIT;
-  return find_buffer_by_handle(buffer, &stub) != NULL;
+  Boolean ret = find_buffer_by_handle(buffer, &stub) != NULL;
+  xfree(stub.msg);
+  return ret;
 }
 
 /// Inserts a sequence of lines to a buffer at a certain index
@@ -678,7 +680,7 @@ ArrayOf(Integer, 2) nvim_buf_get_mark(Buffer buffer, String name, Error *err)
   }
 
   if (name.size != 1) {
-    api_set_error(err, Validation, _("Mark name must be a single character"));
+    _api_set_error(err, kErrorTypeValidation, _("Mark name must be a single character"));
     return rv;
   }
 
@@ -696,7 +698,7 @@ ArrayOf(Integer, 2) nvim_buf_get_mark(Buffer buffer, String name, Error *err)
   }
 
   if (posp == NULL) {
-    api_set_error(err, Validation, _("Invalid mark name"));
+    _api_set_error(err, kErrorTypeValidation, _("Invalid mark name"));
     return rv;
   }
 
@@ -751,11 +753,11 @@ Integer nvim_buf_add_highlight(Buffer buffer,
   }
 
   if (line < 0 || line >= MAXLNUM) {
-    api_set_error(err, Validation, _("Line number outside range"));
+    _api_set_error(err, kErrorTypeValidation, _("Line number outside range"));
     return 0;
   }
   if (col_start < 0 || col_start > MAXCOL) {
-    api_set_error(err, Validation, _("Column value outside range"));
+    _api_set_error(err, kErrorTypeValidation, _("Column value outside range"));
     return 0;
   }
   if (col_end < 0 || col_end > MAXCOL) {
@@ -792,7 +794,7 @@ void nvim_buf_clear_highlight(Buffer buffer,
   }
 
   if (line_start < 0 || line_start >= MAXLNUM) {
-    api_set_error(err, Validation, _("Line number outside range"));
+    _api_set_error(err, kErrorTypeValidation, _("Line number outside range"));
     return;
   }
   if (line_end < 0 || line_end > MAXLNUM) {
diff --git a/src/nvim/api/private/defs.h b/src/nvim/api/private/defs.h
index 223aab09dc..a07422bd12 100644
--- a/src/nvim/api/private/defs.h
+++ b/src/nvim/api/private/defs.h
@@ -8,7 +8,7 @@
 #define ARRAY_DICT_INIT {.size = 0, .capacity = 0, .items = NULL}
 #define STRING_INIT {.data = NULL, .size = 0}
 #define OBJECT_INIT { .type = kObjectTypeNil }
-#define ERROR_INIT { .set = false }
+#define ERROR_INIT { .set = false, .msg = NULL }
 #define REMOTE_TYPE(type) typedef handle_T type
 
 #ifdef INCLUDE_GENERATED_DECLARATIONS
@@ -38,7 +38,7 @@ typedef enum {
 
 typedef struct {
   ErrorType type;
-  char msg[1024];
+  char *msg;
   bool set;
 } Error;
 
diff --git a/src/nvim/api/private/helpers.c b/src/nvim/api/private/helpers.c
index 5877b848fc..e6632525e1 100644
--- a/src/nvim/api/private/helpers.c
+++ b/src/nvim/api/private/helpers.c
@@ -61,7 +61,7 @@ bool try_end(Error *err)
       discard_current_exception();
     }
 
-    api_set_error(err, Exception, _("Keyboard interrupt"));
+    _api_set_error(err, kErrorTypeException, _("Keyboard interrupt"));
     got_int = false;
   } else if (msg_list != NULL && *msg_list != NULL) {
     int should_free;
@@ -69,15 +69,14 @@ bool try_end(Error *err)
                                              ET_ERROR,
                                              NULL,
                                              &should_free);
-    xstrlcpy(err->msg, msg, sizeof(err->msg));
-    err->set = true;
+    _api_set_error(err, err->type, "%s", msg);
     free_global_msglist();
 
     if (should_free) {
       xfree(msg);
     }
   } else if (did_throw) {
-    api_set_error(err, Exception, "%s", current_exception->value);
+    _api_set_error(err, kErrorTypeException, "%s", current_exception->value);
     discard_current_exception();
   }
 
@@ -94,7 +93,7 @@ Object dict_get_value(dict_T *dict, String key, Error *err)
   dictitem_T *const di = tv_dict_find(dict, key.data, (ptrdiff_t)key.size);
 
   if (di == NULL) {
-    api_set_error(err, Validation, _("Key not found"));
+    _api_set_error(err, kErrorTypeValidation, _("Key not found"));
     return (Object) OBJECT_INIT;
   }
 
@@ -118,17 +117,17 @@ Object dict_set_var(dict_T *dict, String key, Object value, bool del,
   Object rv = OBJECT_INIT;
 
   if (dict->dv_lock) {
-    api_set_error(err, Exception, _("Dictionary is locked"));
+    _api_set_error(err, kErrorTypeException, _("Dictionary is locked"));
     return rv;
   }
 
   if (key.size == 0) {
-    api_set_error(err, Validation, _("Empty variable names aren't allowed"));
+    _api_set_error(err, kErrorTypeValidation, _("Empty variable names aren't allowed"));
     return rv;
   }
 
   if (key.size > INT_MAX) {
-    api_set_error(err, Validation, _("Key length is too high"));
+    _api_set_error(err, kErrorTypeValidation, _("Key length is too high"));
     return rv;
   }
 
@@ -136,13 +135,13 @@ Object dict_set_var(dict_T *dict, String key, Object value, bool del,
 
   if (di != NULL) {
     if (di->di_flags & DI_FLAGS_RO) {
-      api_set_error(err, Exception, _("Key is read-only: %s"), key.data);
+      _api_set_error(err, kErrorTypeException, _("Key is read-only: %s"), key.data);
       return rv;
     } else if (di->di_flags & DI_FLAGS_FIX) {
-      api_set_error(err, Exception, _("Key is fixed: %s"), key.data);
+      _api_set_error(err, kErrorTypeException, _("Key is fixed: %s"), key.data);
       return rv;
     } else if (di->di_flags & DI_FLAGS_LOCK) {
-      api_set_error(err, Exception, _("Key is locked: %s"), key.data);
+      _api_set_error(err, kErrorTypeException, _("Key is locked: %s"), key.data);
       return rv;
     }
   }
@@ -151,7 +150,7 @@ Object dict_set_var(dict_T *dict, String key, Object value, bool del,
     // Delete the key
     if (di == NULL) {
       // Doesn't exist, fail
-      api_set_error(err, Validation, _("Key \"%s\" doesn't exist"), key.data);
+      _api_set_error(err, kErrorTypeValidation, _("Key \"%s\" doesn't exist"), key.data);
     } else {
       // Return the old value
       if (retval) {
@@ -203,7 +202,7 @@ Object get_option_from(void *from, int type, String name, Error *err)
   Object rv = OBJECT_INIT;
 
   if (name.size == 0) {
-    api_set_error(err, Validation, _("Empty option name"));
+    _api_set_error(err, kErrorTypeValidation, _("Empty option name"));
     return rv;
   }
 
@@ -214,8 +213,8 @@ Object get_option_from(void *from, int type, String name, Error *err)
                                       type, from);
 
   if (!flags) {
-    api_set_error(err,
-                  Validation,
+    _api_set_error(err,
+                  kErrorTypeValidation,
                   _("Invalid option name \"%s\""),
                   name.data);
     return rv;
@@ -233,14 +232,14 @@ Object get_option_from(void *from, int type, String name, Error *err)
       rv.data.string.data = stringval;
       rv.data.string.size = strlen(stringval);
     } else {
-      api_set_error(err,
-                    Exception,
+      _api_set_error(err,
+                    kErrorTypeException,
                     _("Unable to get value for option \"%s\""),
                     name.data);
     }
   } else {
-    api_set_error(err,
-                  Exception,
+    _api_set_error(err,
+                  kErrorTypeException,
                   _("Unknown type for option \"%s\""),
                   name.data);
   }
@@ -258,15 +257,15 @@ Object get_option_from(void *from, int type, String name, Error *err)
 void set_option_to(void *to, int type, String name, Object value, Error *err)
 {
   if (name.size == 0) {
-    api_set_error(err, Validation, _("Empty option name"));
+    _api_set_error(err, kErrorTypeValidation, _("Empty option name"));
     return;
   }
 
   int flags = get_option_value_strict(name.data, NULL, NULL, type, to);
 
   if (flags == 0) {
-    api_set_error(err,
-                  Validation,
+    _api_set_error(err,
+                  kErrorTypeValidation,
                   _("Invalid option name \"%s\""),
                   name.data);
     return;
@@ -274,14 +273,14 @@ void set_option_to(void *to, int type, String name, Object value, Error *err)
 
   if (value.type == kObjectTypeNil) {
     if (type == SREQ_GLOBAL) {
-      api_set_error(err,
-                    Exception,
+      _api_set_error(err,
+                    kErrorTypeException,
                     _("Unable to unset option \"%s\""),
                     name.data);
       return;
     } else if (!(flags & SOPT_GLOBAL)) {
-      api_set_error(err,
-                    Exception,
+      _api_set_error(err,
+                    kErrorTypeException,
                     _("Cannot unset option \"%s\" "
                       "because it doesn't have a global value"),
                     name.data);
@@ -296,8 +295,8 @@ void set_option_to(void *to, int type, String name, Object value, Error *err)
 
   if (flags & SOPT_BOOL) {
     if (value.type != kObjectTypeBoolean) {
-      api_set_error(err,
-                    Validation,
+      _api_set_error(err,
+                    kErrorTypeValidation,
                     _("Option \"%s\" requires a boolean value"),
                     name.data);
       return;
@@ -307,16 +306,16 @@ void set_option_to(void *to, int type, String name, Object value, Error *err)
     set_option_value_for(name.data, val, NULL, opt_flags, type, to, err);
   } else if (flags & SOPT_NUM) {
     if (value.type != kObjectTypeInteger) {
-      api_set_error(err,
-                    Validation,
+      _api_set_error(err,
+                    kErrorTypeValidation,
                     _("Option \"%s\" requires an integer value"),
                     name.data);
       return;
     }
 
     if (value.data.integer > INT_MAX || value.data.integer < INT_MIN) {
-      api_set_error(err,
-                    Validation,
+      _api_set_error(err,
+                    kErrorTypeValidation,
                     _("Value for option \"%s\" is outside range"),
                     name.data);
       return;
@@ -326,8 +325,8 @@ void set_option_to(void *to, int type, String name, Object value, Error *err)
     set_option_value_for(name.data, val, NULL, opt_flags, type, to, err);
   } else {
     if (value.type != kObjectTypeString) {
-      api_set_error(err,
-                    Validation,
+      _api_set_error(err,
+                    kErrorTypeValidation,
                     _("Option \"%s\" requires a string value"),
                     name.data);
       return;
@@ -561,13 +560,13 @@ buf_T *find_buffer_by_handle(Buffer buffer, Error *err)
   buf_T *rv = handle_get_buffer(buffer);
 
   if (!rv) {
-    api_set_error(err, Validation, _("Invalid buffer id"));
+    _api_set_error(err, kErrorTypeValidation, _("Invalid buffer id"));
   }
 
   return rv;
 }
 
-win_T * find_window_by_handle(Window window, Error *err)
+win_T *find_window_by_handle(Window window, Error *err)
 {
   if (window == 0) {
     return curwin;
@@ -576,13 +575,13 @@ win_T * find_window_by_handle(Window window, Error *err)
   win_T *rv = handle_get_window(window);
 
   if (!rv) {
-    api_set_error(err, Validation, _("Invalid window id"));
+    _api_set_error(err, kErrorTypeValidation, _("Invalid window id"));
   }
 
   return rv;
 }
 
-tabpage_T * find_tab_by_handle(Tabpage tabpage, Error *err)
+tabpage_T *find_tab_by_handle(Tabpage tabpage, Error *err)
 {
   if (tabpage == 0) {
     return curtab;
@@ -591,7 +590,7 @@ tabpage_T * find_tab_by_handle(Tabpage tabpage, Error *err)
   tabpage_T *rv = handle_get_tabpage(tabpage);
 
   if (!rv) {
-    api_set_error(err, Validation, _("Invalid tabpage id"));
+    _api_set_error(err, kErrorTypeValidation, _("Invalid tabpage id"));
   }
 
   return rv;
@@ -659,7 +658,7 @@ bool object_to_vim(Object obj, typval_T *tv, Error *err)
     case kObjectTypeInteger:
       if (obj.data.integer > VARNUMBER_MAX
           || obj.data.integer < VARNUMBER_MIN) {
-        api_set_error(err, Validation, _("Integer value outside range"));
+        _api_set_error(err, kErrorTypeValidation, _("Integer value outside range"));
         return false;
       }
 
@@ -713,7 +712,7 @@ bool object_to_vim(Object obj, typval_T *tv, Error *err)
         String key = item.key;
 
         if (key.size == 0) {
-          api_set_error(err, Validation,
+          _api_set_error(err, kErrorTypeValidation,
                         _("Empty dictionary keys aren't allowed"));
           // cleanup
           tv_dict_free(dict);
@@ -801,6 +800,12 @@ void api_free_dictionary(Dictionary value)
   xfree(value.items);
 }
 
+void api_free_error(Error *value)
+{
+  xfree(value->msg);
+  value->msg = NULL;
+}
+
 Dictionary api_metadata(void)
 {
   static Dictionary metadata = ARRAY_DICT_INIT;
@@ -926,8 +931,8 @@ static void set_option_value_for(char *key,
         if (try_end(err)) {
           return;
         }
-        api_set_error(err,
-                      Exception,
+        _api_set_error(err,
+                      kErrorTypeException,
                       _("Problem while switching windows"));
         return;
       }
@@ -965,6 +970,26 @@ static void set_option_value_err(char *key,
       return;
     }
 
-    api_set_error(err, Exception, "%s", errmsg);
+    _api_set_error(err, kErrorTypeException, "%s", errmsg);
   }
 }
+
+void _api_set_error(Error *err, ErrorType errType, const char *format, ...)
+  FUNC_ATTR_NONNULL_ALL
+{
+  va_list args1;
+  va_list args2;
+  va_start(args1, format);
+  va_copy(args2, args1);
+  int len = vsnprintf(NULL, 0, format, args1);
+  va_end(args1);
+  assert(len >= 0);
+  // Limit error message to 1 MB.
+  size_t bufsize = MIN((size_t)len + 1, 1024 * 1024);
+  err->msg = xmalloc(bufsize);
+  vsnprintf(err->msg, bufsize, format, args2);
+  va_end(args2);
+
+  err->set = true;
+  err->type = errType;
+}
diff --git a/src/nvim/api/private/helpers.h b/src/nvim/api/private/helpers.h
index 20b4015fb5..681945ac9c 100644
--- a/src/nvim/api/private/helpers.h
+++ b/src/nvim/api/private/helpers.h
@@ -8,16 +8,6 @@
 #include "nvim/memory.h"
 #include "nvim/lib/kvec.h"
 
-// -V:api_set_error:618
-#define api_set_error(err, errtype, ...) \
-  do { \
-    snprintf((err)->msg, \
-             sizeof((err)->msg), \
-             __VA_ARGS__); \
-    (err)->set = true; \
-    (err)->type = kErrorType##errtype; \
-  } while (0)
-
 #define OBJECT_OBJ(o) o
 
 #define BOOLEAN_OBJ(b) ((Object) { \
diff --git a/src/nvim/api/tabpage.c b/src/nvim/api/tabpage.c
index 29592408fc..e6d5f7edad 100644
--- a/src/nvim/api/tabpage.c
+++ b/src/nvim/api/tabpage.c
@@ -193,6 +193,8 @@ Boolean nvim_tabpage_is_valid(Tabpage tabpage)
     FUNC_API_SINCE(1)
 {
   Error stub = ERROR_INIT;
-  return find_tab_by_handle(tabpage, &stub) != NULL;
+  Boolean ret = find_tab_by_handle(tabpage, &stub) != NULL;
+  xfree(stub.msg);
+  return ret;
 }
 
diff --git a/src/nvim/api/ui.c b/src/nvim/api/ui.c
index 2a33d2ad72..534274db0f 100644
--- a/src/nvim/api/ui.c
+++ b/src/nvim/api/ui.c
@@ -55,12 +55,12 @@ void nvim_ui_attach(uint64_t channel_id, Integer width, Integer height,
     FUNC_API_SINCE(1) FUNC_API_NOEVAL
 {
   if (pmap_has(uint64_t)(connected_uis, channel_id)) {
-    api_set_error(err, Exception, _("UI already attached for channel"));
+    _api_set_error(err, kErrorTypeException, _("UI already attached for channel"));
     return;
   }
 
   if (width <= 0 || height <= 0) {
-    api_set_error(err, Validation,
+    _api_set_error(err, kErrorTypeValidation,
                   _("Expected width > 0 and height > 0"));
     return;
   }
@@ -126,7 +126,7 @@ void nvim_ui_detach(uint64_t channel_id, Error *err)
     FUNC_API_SINCE(1) FUNC_API_NOEVAL
 {
   if (!pmap_has(uint64_t)(connected_uis, channel_id)) {
-    api_set_error(err, Exception, _("UI is not attached for channel"));
+    _api_set_error(err, kErrorTypeException, _("UI is not attached for channel"));
     return;
   }
   remote_ui_disconnect(channel_id);
@@ -138,12 +138,12 @@ void nvim_ui_try_resize(uint64_t channel_id, Integer width,
     FUNC_API_SINCE(1) FUNC_API_NOEVAL
 {
   if (!pmap_has(uint64_t)(connected_uis, channel_id)) {
-    api_set_error(err, Exception, _("UI is not attached for channel"));
+    _api_set_error(err, kErrorTypeException, _("UI is not attached for channel"));
     return;
   }
 
   if (width <= 0 || height <= 0) {
-    api_set_error(err, Validation,
+    _api_set_error(err, kErrorTypeValidation,
                   _("Expected width > 0 and height > 0"));
     return;
   }
@@ -159,7 +159,7 @@ void nvim_ui_set_option(uint64_t channel_id, String name,
     FUNC_API_SINCE(1) FUNC_API_NOEVAL
 {
   if (!pmap_has(uint64_t)(connected_uis, channel_id)) {
-    api_set_error(error, Exception, _("UI is not attached for channel"));
+    _api_set_error(error, kErrorTypeException, _("UI is not attached for channel"));
     return;
   }
   UI *ui = pmap_get(uint64_t)(connected_uis, channel_id);
@@ -173,19 +173,19 @@ void nvim_ui_set_option(uint64_t channel_id, String name,
 static void ui_set_option(UI *ui, String name, Object value, Error *error) {
   if (strcmp(name.data, "rgb") == 0) {
     if (value.type != kObjectTypeBoolean) {
-      api_set_error(error, Validation, _("rgb must be a Boolean"));
+      _api_set_error(error, kErrorTypeValidation, _("rgb must be a Boolean"));
       return;
     }
     ui->rgb = value.data.boolean;
   } else if (strcmp(name.data, "popupmenu_external") == 0) {
     if (value.type != kObjectTypeBoolean) {
-      api_set_error(error, Validation,
+      _api_set_error(error, kErrorTypeValidation,
                     _("popupmenu_external must be a Boolean"));
       return;
     }
     ui->pum_external = value.data.boolean;
   } else {
-    api_set_error(error, Validation, _("No such ui option"));
+    _api_set_error(error, kErrorTypeValidation, _("No such ui option"));
   }
 }
 
diff --git a/src/nvim/api/vim.c b/src/nvim/api/vim.c
index e5ef4a35c1..bd4a196367 100644
--- a/src/nvim/api/vim.c
+++ b/src/nvim/api/vim.c
@@ -188,7 +188,7 @@ Object nvim_eval(String expr, Error *err)
 
   typval_T rettv;
   if (eval0((char_u *)expr.data, &rettv, NULL, true) == FAIL) {
-    api_set_error(err, Exception, "Failed to evaluate expression");
+    _api_set_error(err, kErrorTypeException, "Failed to evaluate expression");
   }
 
   if (!try_end(err)) {
@@ -214,7 +214,7 @@ Object nvim_call_function(String fname, Array args, Error *err)
 {
   Object rv = OBJECT_INIT;
   if (args.size > MAX_FUNC_ARGS) {
-    api_set_error(err, Validation,
+    _api_set_error(err, kErrorTypeValidation,
       _("Function called with too many arguments."));
     return rv;
   }
@@ -237,7 +237,7 @@ Object nvim_call_function(String fname, Array args, Error *err)
                     curwin->w_cursor.lnum, curwin->w_cursor.lnum, &dummy,
                     true, NULL, NULL);
   if (r == FAIL) {
-    api_set_error(err, Exception, _("Error calling function."));
+    _api_set_error(err, kErrorTypeException, _("Error calling function."));
   }
   if (!try_end(err)) {
     rv = vim_to_object(&rettv);
@@ -262,7 +262,7 @@ Integer nvim_strwidth(String str, Error *err)
     FUNC_API_SINCE(1)
 {
   if (str.size > INT_MAX) {
-    api_set_error(err, Validation, _("String length is too high"));
+    _api_set_error(err, kErrorTypeValidation, _("String length is too high"));
     return 0;
   }
 
@@ -318,7 +318,7 @@ void nvim_set_current_dir(String dir, Error *err)
     FUNC_API_SINCE(1)
 {
   if (dir.size >= MAXPATHL) {
-    api_set_error(err, Validation, _("Directory string is too long"));
+    _api_set_error(err, kErrorTypeValidation, _("Directory string is too long"));
     return;
   }
 
@@ -330,7 +330,7 @@ void nvim_set_current_dir(String dir, Error *err)
 
   if (vim_chdir((char_u *)string, kCdScopeGlobal)) {
     if (!try_end(err)) {
-      api_set_error(err, Exception, _("Failed to change directory"));
+      _api_set_error(err, kErrorTypeException, _("Failed to change directory"));
     }
     return;
   }
@@ -538,8 +538,8 @@ void nvim_set_current_buf(Buffer buffer, Error *err)
   try_start();
   int result = do_buffer(DOBUF_GOTO, DOBUF_FIRST, FORWARD, buf->b_fnum, 0);
   if (!try_end(err) && result == FAIL) {
-    api_set_error(err,
-                  Exception,
+    _api_set_error(err,
+                  kErrorTypeException,
                   _("Failed to switch to buffer %d"),
                   buffer);
   }
@@ -591,8 +591,8 @@ void nvim_set_current_win(Window window, Error *err)
   try_start();
   goto_tabpage_win(win_find_tabpage(win), win);
   if (!try_end(err) && win != curwin) {
-    api_set_error(err,
-                  Exception,
+    _api_set_error(err,
+                  kErrorTypeException,
                   _("Failed to switch to window %d"),
                   window);
   }
@@ -645,8 +645,8 @@ void nvim_set_current_tabpage(Tabpage tabpage, Error *err)
   try_start();
   goto_tabpage_tp(tp, true, true);
   if (!try_end(err) && tp != curtab) {
-    api_set_error(err,
-                  Exception,
+    _api_set_error(err,
+                  kErrorTypeException,
                   _("Failed to switch to tabpage %d"),
                   tabpage);
   }
@@ -744,30 +744,30 @@ Array nvim_call_atomic(uint64_t channel_id, Array calls, Error *err)
   size_t i;  // also used for freeing the variables
   for (i = 0; i < calls.size; i++) {
     if (calls.items[i].type != kObjectTypeArray) {
-      api_set_error(err,
-                    Validation,
+      _api_set_error(err,
+                    kErrorTypeValidation,
                     _("All items in calls array must be arrays"));
       goto validation_error;
     }
     Array call = calls.items[i].data.array;
     if (call.size != 2) {
-      api_set_error(err,
-                    Validation,
+      _api_set_error(err,
+                    kErrorTypeValidation,
                     _("All items in calls array must be arrays of size 2"));
       goto validation_error;
     }
 
     if (call.items[0].type != kObjectTypeString) {
-      api_set_error(err,
-                    Validation,
+      _api_set_error(err,
+                    kErrorTypeValidation,
                     _("name must be String"));
       goto validation_error;
     }
     String name = call.items[0].data.string;
 
     if (call.items[1].type != kObjectTypeArray) {
-      api_set_error(err,
-                    Validation,
+      _api_set_error(err,
+                    kErrorTypeValidation,
                     _("args must be Array"));
       goto validation_error;
     }
@@ -794,10 +794,12 @@ Array nvim_call_atomic(uint64_t channel_id, Array calls, Error *err)
   } else {
     ADD(rv, NIL);
   }
-  return rv;
+  goto theend;
 
 validation_error:
   api_free_array(results);
+theend:
+  api_free_error(&nested_error);
   return rv;
 }
 
diff --git a/src/nvim/api/window.c b/src/nvim/api/window.c
index e1bb70ee0d..254ab1c09f 100644
--- a/src/nvim/api/window.c
+++ b/src/nvim/api/window.c
@@ -64,8 +64,8 @@ void nvim_win_set_cursor(Window window, ArrayOf(Integer, 2) pos, Error *err)
 
   if (pos.size != 2 || pos.items[0].type != kObjectTypeInteger
       || pos.items[1].type != kObjectTypeInteger) {
-    api_set_error(err,
-                  Validation,
+    _api_set_error(err,
+                  kErrorTypeValidation,
                   _("Argument \"pos\" must be a [row, col] array"));
     return;
   }
@@ -78,12 +78,12 @@ void nvim_win_set_cursor(Window window, ArrayOf(Integer, 2) pos, Error *err)
   int64_t col = pos.items[1].data.integer;
 
   if (row <= 0 || row > win->w_buffer->b_ml.ml_line_count) {
-    api_set_error(err, Validation, _("Cursor position outside buffer"));
+    _api_set_error(err, kErrorTypeValidation, _("Cursor position outside buffer"));
     return;
   }
 
   if (col > MAXCOL || col < 0) {
-    api_set_error(err, Validation, _("Column value outside range"));
+    _api_set_error(err, kErrorTypeValidation, _("Column value outside range"));
     return;
   }
 
@@ -132,7 +132,7 @@ void nvim_win_set_height(Window window, Integer height, Error *err)
   }
 
   if (height > INT_MAX || height < INT_MIN) {
-    api_set_error(err, Validation, _("Height value outside range"));
+    _api_set_error(err, kErrorTypeValidation, _("Height value outside range"));
     return;
   }
 
@@ -177,7 +177,7 @@ void nvim_win_set_width(Window window, Integer width, Error *err)
   }
 
   if (width > INT_MAX || width < INT_MIN) {
-    api_set_error(err, Validation, _("Width value outside range"));
+    _api_set_error(err, kErrorTypeValidation, _("Width value outside range"));
     return;
   }
 
@@ -387,6 +387,8 @@ Boolean nvim_win_is_valid(Window window)
     FUNC_API_SINCE(1)
 {
   Error stub = ERROR_INIT;
-  return find_window_by_handle(window, &stub) != NULL;
+  Boolean ret = find_window_by_handle(window, &stub) != NULL;
+  xfree(stub.msg);
+  return ret;
 }
 
diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index 7cef0d81ed..56dc35c31d 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -6524,6 +6524,7 @@ static void api_wrapper(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 end:
   api_free_array(args);
   api_free_object(result);
+  xfree(err.msg);
 }
 
 /*
@@ -13794,6 +13795,7 @@ static void f_rpcrequest(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 
 end:
   api_free_object(result);
+  xfree(err.msg);
 }
 
 // "rpcstart()" function (DEPRECATED)
@@ -16523,7 +16525,7 @@ static void f_termopen(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   curbuf->b_p_swf = false;
   (void)setfname(curbuf, (char_u *)buf, NULL, true);
   // Save the job id and pid in b:terminal_job_{id,pid}
-  Error err;
+  Error err = ERROR_INIT;
   dict_set_var(curbuf->b_vars, cstr_as_string("terminal_job_id"),
                INTEGER_OBJ(rettv->vval.v_number), false, false, &err);
   dict_set_var(curbuf->b_vars, cstr_as_string("terminal_job_pid"),
@@ -16532,6 +16534,7 @@ static void f_termopen(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   Terminal *term = terminal_open(topts);
   data->term = term;
   data->refcount++;
+  xfree(err.msg);
 
   return;
 }
diff --git a/src/nvim/msgpack_rpc/channel.c b/src/nvim/msgpack_rpc/channel.c
index b2c6ef852c..06cdf7d1f1 100644
--- a/src/nvim/msgpack_rpc/channel.c
+++ b/src/nvim/msgpack_rpc/channel.c
@@ -192,7 +192,7 @@ Object channel_send_call(uint64_t id,
   Channel *channel = NULL;
 
   if (!(channel = pmap_get(uint64_t)(channels, id)) || channel->closed) {
-    api_set_error(err, Exception, _("Invalid channel \"%" PRIu64 "\""), id);
+    _api_set_error(err, kErrorTypeException, _("Invalid channel \"%" PRIu64 "\""), id);
     api_free_array(args);
     return NIL;
   }
@@ -212,7 +212,7 @@ Object channel_send_call(uint64_t id,
 
   if (frame.errored) {
     if (frame.result.type == kObjectTypeString) {
-      api_set_error(err, Exception, "%s", frame.result.data.string.data);
+      _api_set_error(err, kErrorTypeException, "%s", frame.result.data.string.data);
     } else if (frame.result.type == kObjectTypeArray) {
       // Should be an error in the form [type, message]
       Array array = frame.result.data.array;
@@ -220,14 +220,13 @@ Object channel_send_call(uint64_t id,
           && (array.items[0].data.integer == kErrorTypeException
               || array.items[0].data.integer == kErrorTypeValidation)
           && array.items[1].type == kObjectTypeString) {
-        err->type = (ErrorType) array.items[0].data.integer;
-        xstrlcpy(err->msg, array.items[1].data.string.data, sizeof(err->msg));
-        err->set = true;
+        _api_set_error(err, (ErrorType)array.items[0].data.integer, "%s",
+                       array.items[1].data.string.data);
       } else {
-        api_set_error(err, Exception, "%s", "unknown error");
+        _api_set_error(err, kErrorTypeException, "%s", "unknown error");
       }
     } else {
-      api_set_error(err, Exception, "%s", "unknown error");
+      _api_set_error(err, kErrorTypeException, "%s", "unknown error");
     }
 
     api_free_object(frame.result);
@@ -412,38 +411,38 @@ static void handle_request(Channel *channel, msgpack_object *request)
                channel->id);
       call_set_error(channel, buf);
     }
-    return;
-  }
-
-  // Retrieve the request handler
-  MsgpackRpcRequestHandler handler;
-  msgpack_object *method = msgpack_rpc_method(request);
-
-  if (method) {
-    handler = msgpack_rpc_get_handler_for(method->via.bin.ptr,
-                                          method->via.bin.size);
   } else {
-    handler.fn = msgpack_rpc_handle_missing_method;
-    handler.async = true;
-  }
+    // Retrieve the request handler
+    MsgpackRpcRequestHandler handler;
+    msgpack_object *method = msgpack_rpc_method(request);
 
-  Array args = ARRAY_DICT_INIT;
-  if (!msgpack_rpc_to_array(msgpack_rpc_args(request), &args)) {
-    handler.fn = msgpack_rpc_handle_invalid_arguments;
-    handler.async = true;
-  }
+    if (method) {
+      handler = msgpack_rpc_get_handler_for(method->via.bin.ptr,
+                                            method->via.bin.size);
+    } else {
+      handler.fn = msgpack_rpc_handle_missing_method;
+      handler.async = true;
+    }
 
-  RequestEvent *event_data = xmalloc(sizeof(RequestEvent));
-  event_data->channel = channel;
-  event_data->handler = handler;
-  event_data->args = args;
-  event_data->request_id = request_id;
-  incref(channel);
-  if (handler.async) {
-    on_request_event((void **)&event_data);
-  } else {
-    multiqueue_put(channel->events, on_request_event, 1, event_data);
+    Array args = ARRAY_DICT_INIT;
+    if (!msgpack_rpc_to_array(msgpack_rpc_args(request), &args)) {
+      handler.fn = msgpack_rpc_handle_invalid_arguments;
+      handler.async = true;
+    }
+
+    RequestEvent *event_data = xmalloc(sizeof(RequestEvent));
+    event_data->channel = channel;
+    event_data->handler = handler;
+    event_data->args = args;
+    event_data->request_id = request_id;
+    incref(channel);
+    if (handler.async) {
+      on_request_event((void **)&event_data);
+    } else {
+      multiqueue_put(channel->events, on_request_event, 1, event_data);
+    }
   }
+  xfree(error.msg);
 }
 
 static void on_request_event(void **argv)
@@ -470,6 +469,7 @@ static void on_request_event(void **argv)
   api_free_array(args);
   decref(channel);
   xfree(e);
+  xfree(error.msg);
 }
 
 static bool channel_write(Channel *channel, WBuffer *buffer)
@@ -512,12 +512,13 @@ static bool channel_write(Channel *channel, WBuffer *buffer)
 static void send_error(Channel *channel, uint64_t id, char *err)
 {
   Error e = ERROR_INIT;
-  api_set_error(&e, Exception, "%s", err);
+  _api_set_error(&e, kErrorTypeException, "%s", err);
   channel_write(channel, serialize_response(channel->id,
                                             id,
                                             &e,
                                             NIL,
                                             &out_buffer));
+  xfree(e.msg);
 }
 
 static void send_request(Channel *channel,
diff --git a/src/nvim/msgpack_rpc/helpers.c b/src/nvim/msgpack_rpc/helpers.c
index 967ce31c1b..c273343b41 100644
--- a/src/nvim/msgpack_rpc/helpers.c
+++ b/src/nvim/msgpack_rpc/helpers.c
@@ -475,8 +475,7 @@ Object msgpack_rpc_handle_missing_method(uint64_t channel_id,
                                          Array args,
                                          Error *error)
 {
-  snprintf(error->msg, sizeof(error->msg), "Invalid method name");
-  error->set = true;
+  _api_set_error(error, error->type, "Invalid method name");
   return NIL;
 }
 
@@ -485,8 +484,7 @@ Object msgpack_rpc_handle_invalid_arguments(uint64_t channel_id,
                                             Array args,
                                             Error *error)
 {
-  snprintf(error->msg, sizeof(error->msg), "Invalid method arguments");
-  error->set = true;
+  _api_set_error(error, error->type, "Invalid method arguments");
   return NIL;
 }
 
@@ -572,29 +570,29 @@ void msgpack_rpc_validate(uint64_t *response_id,
   *response_id = NO_RESPONSE;
   // Validate the basic structure of the msgpack-rpc payload
   if (req->type != MSGPACK_OBJECT_ARRAY) {
-    api_set_error(err, Validation, _("Message is not an array"));
+    _api_set_error(err, kErrorTypeValidation, _("Message is not an array"));
     return;
   }
 
   if (req->via.array.size == 0) {
-    api_set_error(err, Validation, _("Message is empty"));
+    _api_set_error(err, kErrorTypeValidation, _("Message is empty"));
     return;
   }
 
   if (req->via.array.ptr[0].type != MSGPACK_OBJECT_POSITIVE_INTEGER) {
-    api_set_error(err, Validation, _("Message type must be an integer"));
+    _api_set_error(err, kErrorTypeValidation, _("Message type must be an integer"));
     return;
   }
 
   uint64_t type = req->via.array.ptr[0].via.u64;
   if (type != kMessageTypeRequest && type != kMessageTypeNotification) {
-    api_set_error(err, Validation, _("Unknown message type"));
+    _api_set_error(err, kErrorTypeValidation, _("Unknown message type"));
     return;
   }
 
   if ((type == kMessageTypeRequest && req->via.array.size != 4)
       || (type == kMessageTypeNotification && req->via.array.size != 3)) {
-    api_set_error(err, Validation, _("Request array size should be 4 (request) "
+    _api_set_error(err, kErrorTypeValidation, _("Request array size should be 4 (request) "
                                      "or 3 (notification)"));
     return;
   }
@@ -602,19 +600,19 @@ void msgpack_rpc_validate(uint64_t *response_id,
   if (type == kMessageTypeRequest) {
     msgpack_object *id_obj = msgpack_rpc_msg_id(req);
     if (!id_obj) {
-      api_set_error(err, Validation, _("ID must be a positive integer"));
+      _api_set_error(err, kErrorTypeValidation, _("ID must be a positive integer"));
       return;
     }
     *response_id = id_obj->via.u64;
   }
 
   if (!msgpack_rpc_method(req)) {
-    api_set_error(err, Validation, _("Method must be a string"));
+    _api_set_error(err, kErrorTypeValidation, _("Method must be a string"));
     return;
   }
 
   if (!msgpack_rpc_args(req)) {
-    api_set_error(err, Validation, _("Parameters must be an array"));
+    _api_set_error(err, kErrorTypeValidation, _("Parameters must be an array"));
     return;
   }
 }
diff --git a/src/nvim/terminal.c b/src/nvim/terminal.c
index 19b9bdc19f..43e4ea87e3 100644
--- a/src/nvim/terminal.c
+++ b/src/nvim/terminal.c
@@ -633,13 +633,14 @@ static int term_movecursor(VTermPos new, VTermPos old, int visible,
 static void buf_set_term_title(buf_T *buf, char *title)
     FUNC_ATTR_NONNULL_ALL
 {
-  Error err;
+  Error err = ERROR_INIT;
   dict_set_var(buf->b_vars,
                STATIC_CSTR_AS_STRING("term_title"),
                STRING_OBJ(cstr_as_string(title)),
                false,
                false,
                &err);
+  xfree(err.msg);
 }
 
 static int term_settermprop(VTermProp prop, VTermValue *val, void *data)
@@ -1220,12 +1221,15 @@ static bool is_focused(Terminal *term)
 
 #define GET_CONFIG_VALUE(k, o) \
   do { \
-    Error err; \
+    Error err = ERROR_INIT; \
     /* Only called from terminal_open where curbuf->terminal is the */ \
     /* context  */ \
     o = dict_get_value(curbuf->b_vars, cstr_as_string(k), &err); \
+    xfree(err.msg); \
     if (o.type == kObjectTypeNil) { \
-      o = dict_get_value(&globvardict, cstr_as_string(k), &err); \
+      Error err2 = ERROR_INIT; \
+      o = dict_get_value(&globvardict, cstr_as_string(k), &err2); \
+      xfree(err2.msg); \
     } \
   } while (0)
 
diff --git a/src/nvim/tui/input.c b/src/nvim/tui/input.c
index 3f2ccd4746..921f67fb7d 100644
--- a/src/nvim/tui/input.c
+++ b/src/nvim/tui/input.c
@@ -228,7 +228,7 @@ static int get_key_code_timeout(void)
   if (nvim_get_option(cstr_as_string("ttimeout"), &err).data.boolean) {
     ms = nvim_get_option(cstr_as_string("ttimeoutlen"), &err).data.integer;
   }
-
+  xfree(err.msg);
   return (int)ms;
 }