api/msgpack-rpc: Remove specialized array types

Specialized array types(BufferArray, WindowArray, etc) were added to the API for
two main reasons:

- msgpack used to lack a way of serializing appliaction-specific types and there
  was no obvious way of making an API function accept/return arrays of custom
  objects such as buffers(which are represented as integers, so clients didn't
  have a way to distinguish from normal numbers)
- Let clients in statically-typed languages that support generics have a better
  typed API

With msgpack 2.0 EXT type the first item is no longer a factor and this commit
starts by removing the specialized array types. The second item will be
addressed in the future by making the API metadata return extra useful
information for statically-typed languages.

6 files changed, 49 insertions, 155 deletions

diff --git a/src/nvim/api/buffer.c b/src/nvim/api/buffer.c
index a268e04559..380de12c89 100644
--- a/src/nvim/api/buffer.c
+++ b/src/nvim/api/buffer.c
@@ -51,10 +51,10 @@ Integer buffer_get_length(Buffer buffer, Error *err)
 String buffer_get_line(Buffer buffer, Integer index, Error *err)
 {
   String rv = {.size = 0};
-  StringArray slice = buffer_get_slice(buffer, index, index, true, true, err);
+  Array slice = buffer_get_slice(buffer, index, index, true, true, err);
 
   if (!err->set && slice.size) {
-    rv = slice.items[0];
+    rv = slice.items[0].data.string;
   }
 
   free(slice.items);
@@ -70,7 +70,8 @@ String buffer_get_line(Buffer buffer, Integer index, Error *err)
 /// @param[out] err Details of an error that may have occurred
 void buffer_set_line(Buffer buffer, Integer index, String line, Error *err)
 {
-  StringArray array = {.items = &line, .size = 1};
+  Object l = STRING_OBJ(line);
+  Array array = {.items = &l, .size = 1};
   buffer_set_slice(buffer, index, index, true, true, array, err);
 }
 
@@ -81,7 +82,7 @@ void buffer_set_line(Buffer buffer, Integer index, String line, Error *err)
 /// @param[out] err Details of an error that may have occurred
 void buffer_del_line(Buffer buffer, Integer index, Error *err)
 {
-  StringArray array = ARRAY_DICT_INIT;
+  Array array = ARRAY_DICT_INIT;
   buffer_set_slice(buffer, index, index, true, true, array, err);
 }
 
@@ -94,14 +95,14 @@ void buffer_del_line(Buffer buffer, Integer index, Error *err)
 /// @param include_end True if the slice includes the `end` parameter
 /// @param[out] err Details of an error that may have occurred
 /// @return An array of lines
-StringArray buffer_get_slice(Buffer buffer,
-                             Integer start,
-                             Integer end,
-                             Boolean include_start,
-                             Boolean include_end,
-                             Error *err)
+Array buffer_get_slice(Buffer buffer,
+                       Integer start,
+                       Integer end,
+                       Boolean include_start,
+                       Boolean include_end,
+                       Error *err)
 {
-  StringArray rv = ARRAY_DICT_INIT;
+  Array rv = ARRAY_DICT_INIT;
   buf_T *buf = find_buffer_by_handle(buffer, err);
 
   if (!buf) {
@@ -118,7 +119,7 @@ StringArray buffer_get_slice(Buffer buffer,
   }
 
   rv.size = (size_t)(end - start);
-  rv.items = xcalloc(sizeof(String), rv.size);
+  rv.items = xcalloc(sizeof(Object), rv.size);
 
   for (size_t i = 0; i < rv.size; i++) {
     int64_t lnum = start + (int64_t)i;
@@ -129,13 +130,13 @@ StringArray buffer_get_slice(Buffer buffer,
     }
 
     const char *bufstr = (char *) ml_get_buf(buf, (linenr_T) lnum, false);
-    rv.items[i] = cstr_to_string(bufstr);
+    rv.items[i] = STRING_OBJ(cstr_to_string(bufstr));
   }
 
 end:
   if (err->set) {
     for (size_t i = 0; i < rv.size; i++) {
-      free(rv.items[i].data);
+      free(rv.items[i].data.string.data);
     }
 
     free(rv.items);
@@ -152,15 +153,15 @@ end:
 /// @param end The last line index
 /// @param include_start True if the slice includes the `start` parameter
 /// @param include_end True if the slice includes the `end` parameter
-/// @param lines An array of lines to use as replacement(A 0-length array
-///        will simply delete the line range)
+/// @param replacement An array of lines to use as replacement(A 0-length
+//         array will simply delete the line range)
 /// @param[out] err Details of an error that may have occurred
 void buffer_set_slice(Buffer buffer,
                       Integer start,
                       Integer end,
                       Boolean include_start,
                       Boolean include_end,
-                      StringArray replacement,
+                      Array replacement,
                       Error *err)
 {
   buf_T *buf = find_buffer_by_handle(buffer, err);
@@ -184,10 +185,15 @@ void buffer_set_slice(Buffer buffer,
   size_t new_len = replacement.size;
   size_t old_len = (size_t)(end - start);
   ssize_t extra = 0;  // lines added to text, can be negative
-  char **lines = (new_len != 0) ? xmalloc(new_len * sizeof(char *)) : NULL;
+  char **lines = (new_len != 0) ? xcalloc(new_len, sizeof(char *)) : NULL;
 
   for (size_t i = 0; i < new_len; i++) {
-    String l = replacement.items[i];
+    if (replacement.items[i].type != kObjectTypeString) {
+      set_api_error("all items in the replacement array must be strings", err);
+      goto end;
+    }
+
+    String l = replacement.items[i].data.string;
     lines[i] = xmemdupz(l.data, l.size);
   }
 
@@ -430,7 +436,7 @@ Boolean buffer_is_valid(Buffer buffer)
 ///        to the end of the buffer.
 /// @param lines An array of lines
 /// @param[out] err Details of an error that may have occurred
-void buffer_insert(Buffer buffer, Integer lnum, StringArray lines, Error *err)
+void buffer_insert(Buffer buffer, Integer lnum, Array lines, Error *err)
 {
   buffer_set_slice(buffer, lnum, lnum, false, true, lines, err);
 }
diff --git a/src/nvim/api/private/defs.h b/src/nvim/api/private/defs.h
index b049412014..071563a628 100644
--- a/src/nvim/api/private/defs.h
+++ b/src/nvim/api/private/defs.h
@@ -11,12 +11,6 @@
 #define POSITION_INIT { .row = 0, .col = 0 }
 #define REMOTE_TYPE(type) typedef uint64_t type
 
-#define TYPED_ARRAY_OF(type)                                                  \
-  typedef struct {                                                            \
-    type *items;                                                              \
-    size_t size;                                                              \
-  } type##Array
-
 // Basic types
 typedef struct {
   char msg[256];
@@ -38,11 +32,6 @@ REMOTE_TYPE(Tabpage);
 
 typedef struct object Object;
 
-TYPED_ARRAY_OF(Buffer);
-TYPED_ARRAY_OF(Window);
-TYPED_ARRAY_OF(Tabpage);
-TYPED_ARRAY_OF(String);
-
 typedef struct {
   Integer row, col;
 } Position;
@@ -71,10 +60,6 @@ typedef enum {
   kObjectTypeArray,
   kObjectTypeDictionary,
   kObjectTypePosition,
-  kObjectTypeStringArray,
-  kObjectTypeBufferArray,
-  kObjectTypeWindowArray,
-  kObjectTypeTabpageArray,
 } ObjectType;
 
 struct object {
@@ -90,10 +75,6 @@ struct object {
     Array array;
     Dictionary dictionary;
     Position position;
-    StringArray stringarray;
-    BufferArray bufferarray;
-    WindowArray windowarray;
-    TabpageArray tabpagearray;
   } data;
 };
 
diff --git a/src/nvim/api/tabpage.c b/src/nvim/api/tabpage.c
index 535722c087..901f9a6c1a 100644
--- a/src/nvim/api/tabpage.c
+++ b/src/nvim/api/tabpage.c
@@ -13,9 +13,9 @@
 /// @param tabpage The tabpage
 /// @param[out] err Details of an error that may have occurred
 /// @return The number of windows in `tabpage`
-WindowArray tabpage_get_windows(Tabpage tabpage, Error *err)
+Array tabpage_get_windows(Tabpage tabpage, Error *err)
 {
-  WindowArray rv = ARRAY_DICT_INIT;
+  Array rv = ARRAY_DICT_INIT;
   tabpage_T *tab = find_tab_by_handle(tabpage, err);
 
   if (!tab) {
@@ -32,14 +32,14 @@ WindowArray tabpage_get_windows(Tabpage tabpage, Error *err)
     rv.size++;
   }
 
-  rv.items = xmalloc(sizeof(Window) * rv.size);
+  rv.items = xmalloc(sizeof(Object) * rv.size);
   size_t i = 0;
 
   FOR_ALL_TAB_WINDOWS(tp, wp) {
     if (tp != tab) {
       break;
     }
-    rv.items[i++] = wp->handle;
+    rv.items[i++] = WINDOW_OBJ(wp->handle);
   }
 
   return rv;
diff --git a/src/nvim/api/vim.c b/src/nvim/api/vim.c
index a2c50b4c81..b1d5a067b4 100644
--- a/src/nvim/api/vim.c
+++ b/src/nvim/api/vim.c
@@ -149,9 +149,9 @@ Integer vim_strwidth(String str, Error *err)
 /// Returns a list of paths contained in 'runtimepath'
 ///
 /// @return The list of paths
-StringArray vim_list_runtime_paths(void)
+Array vim_list_runtime_paths(void)
 {
-  StringArray rv = ARRAY_DICT_INIT;
+  Array rv = ARRAY_DICT_INIT;
   uint8_t *rtp = p_rtp;
 
   if (*rtp == NUL) {
@@ -168,19 +168,20 @@ StringArray vim_list_runtime_paths(void)
   }
 
   // Allocate memory for the copies
-  rv.items = xmalloc(sizeof(String) * rv.size);
+  rv.items = xmalloc(sizeof(Object) * rv.size);
   // reset the position
   rtp = p_rtp;
   // Start copying
   for (size_t i = 0; i < rv.size && *rtp != NUL; i++) {
-    rv.items[i].data = xmalloc(MAXPATHL);
+    rv.items[i].type = kObjectTypeString;
+    rv.items[i].data.string.data = xmalloc(MAXPATHL);
     // Copy the path from 'runtimepath' to rv.items[i]
     int length = copy_option_part(&rtp,
-                                 (char_u *)rv.items[i].data,
+                                 (char_u *)rv.items[i].data.string.data,
                                  MAXPATHL,
                                  ",");
     assert(length >= 0);
-    rv.items[i].size = (size_t)length;
+    rv.items[i].data.string.size = (size_t)length;
   }
 
   return rv;
@@ -310,9 +311,9 @@ void vim_err_write(String str)
 /// Gets the current list of buffer handles
 ///
 /// @return The number of buffers
-BufferArray vim_get_buffers(void)
+Array vim_get_buffers(void)
 {
-  BufferArray rv = ARRAY_DICT_INIT;
+  Array rv = ARRAY_DICT_INIT;
   buf_T *b = firstbuf;
 
   while (b) {
@@ -320,12 +321,12 @@ BufferArray vim_get_buffers(void)
     b = b->b_next;
   }
 
-  rv.items = xmalloc(sizeof(Buffer) * rv.size);
+  rv.items = xmalloc(sizeof(Object) * rv.size);
   size_t i = 0;
   b = firstbuf;
 
   while (b) {
-    rv.items[i++] = b->handle;
+    rv.items[i++] = BUFFER_OBJ(b->handle);
     b = b->b_next;
   }
 
@@ -370,9 +371,9 @@ void vim_set_current_buffer(Buffer buffer, Error *err)
 /// Gets the current list of window handles
 ///
 /// @return The number of windows
-WindowArray vim_get_windows(void)
+Array vim_get_windows(void)
 {
-  WindowArray rv = ARRAY_DICT_INIT;
+  Array rv = ARRAY_DICT_INIT;
   tabpage_T *tp;
   win_T *wp;
 
@@ -380,11 +381,11 @@ WindowArray vim_get_windows(void)
     rv.size++;
   }
 
-  rv.items = xmalloc(sizeof(Window) * rv.size);
+  rv.items = xmalloc(sizeof(Object) * rv.size);
   size_t i = 0;
 
   FOR_ALL_TAB_WINDOWS(tp, wp) {
-    rv.items[i++] = wp->handle;
+    rv.items[i++] = WINDOW_OBJ(wp->handle);
   }
 
   return rv;
@@ -426,9 +427,9 @@ void vim_set_current_window(Window window, Error *err)
 /// Gets the current list of tabpage handles
 ///
 /// @return The number of tab pages
-TabpageArray vim_get_tabpages(void)
+Array vim_get_tabpages(void)
 {
-  TabpageArray rv = ARRAY_DICT_INIT;
+  Array rv = ARRAY_DICT_INIT;
   tabpage_T *tp = first_tabpage;
 
   while (tp) {
@@ -436,12 +437,12 @@ TabpageArray vim_get_tabpages(void)
     tp = tp->tp_next;
   }
 
-  rv.items = xmalloc(sizeof(Tabpage) * rv.size);
+  rv.items = xmalloc(sizeof(Object) * rv.size);
   size_t i = 0;
   tp = first_tabpage;
 
   while (tp) {
-    rv.items[i++] = tp->handle;
+    rv.items[i++] = TABPAGE_OBJ(tp->handle);
     tp = tp->tp_next;
   }
 
diff --git a/src/nvim/os/msgpack_rpc_helpers.c b/src/nvim/os/msgpack_rpc_helpers.c
index eaba3b9785..3210f2b6b2 100644
--- a/src/nvim/os/msgpack_rpc_helpers.c
+++ b/src/nvim/os/msgpack_rpc_helpers.c
@@ -19,42 +19,6 @@
     msgpack_pack_uint64(res, result);                                       \
   }
 
-#define TYPED_ARRAY_IMPL(t, lt)                                             \
-  bool msgpack_rpc_to_##lt##array(msgpack_object *obj, t##Array *arg)       \
-  {                                                                         \
-    if (obj->type != MSGPACK_OBJECT_ARRAY) {                                \
-      return false;                                                         \
-    }                                                                       \
-                                                                            \
-    arg->size = obj->via.array.size;                                        \
-    arg->items = xcalloc(obj->via.array.size, sizeof(t));                   \
-                                                                            \
-    for (size_t i = 0; i < obj->via.array.size; i++) {                      \
-      if (!msgpack_rpc_to_##lt(obj->via.array.ptr + i, &arg->items[i])) {   \
-        return false;                                                       \
-      }                                                                     \
-    }                                                                       \
-                                                                            \
-    return true;                                                            \
-  }                                                                         \
-                                                                            \
-  void msgpack_rpc_from_##lt##array(t##Array result, msgpack_packer *res)   \
-  {                                                                         \
-    msgpack_pack_array(res, result.size);                                   \
-                                                                            \
-    for (size_t i = 0; i < result.size; i++) {                              \
-      msgpack_rpc_from_##lt(result.items[i], res);                          \
-    }                                                                       \
-  }                                                                         \
-                                                                            \
-  void msgpack_rpc_free_##lt##array(t##Array value) {                       \
-    for (size_t i = 0; i < value.size; i++) {                               \
-      msgpack_rpc_free_##lt(value.items[i]);                                \
-    }                                                                       \
-                                                                            \
-    free(value.items);                                                      \
-  }
-
 bool msgpack_rpc_to_boolean(msgpack_object *obj, Boolean *arg)
 {
   *arg = obj->via.boolean;
@@ -249,22 +213,6 @@ void msgpack_rpc_from_object(Object result, msgpack_packer *res)
       msgpack_rpc_from_tabpage(result.data.tabpage, res);
       break;
 
-    case kObjectTypeStringArray:
-      msgpack_rpc_from_stringarray(result.data.stringarray, res);
-      break;
-
-    case kObjectTypeBufferArray:
-      msgpack_rpc_from_bufferarray(result.data.bufferarray, res);
-      break;
-
-    case kObjectTypeWindowArray:
-      msgpack_rpc_from_windowarray(result.data.windowarray, res);
-      break;
-
-    case kObjectTypeTabpageArray:
-      msgpack_rpc_from_tabpagearray(result.data.tabpagearray, res);
-      break;
-
     case kObjectTypeDictionary:
       msgpack_rpc_from_dictionary(result.data.dictionary, res);
       break;
@@ -327,22 +275,6 @@ void msgpack_rpc_free_object(Object value)
       msgpack_rpc_free_array(value.data.array);
       break;
 
-    case kObjectTypeStringArray:
-      msgpack_rpc_free_stringarray(value.data.stringarray);
-      break;
-
-    case kObjectTypeBufferArray:
-      msgpack_rpc_free_bufferarray(value.data.bufferarray);
-      break;
-
-    case kObjectTypeWindowArray:
-      msgpack_rpc_free_windowarray(value.data.windowarray);
-      break;
-
-    case kObjectTypeTabpageArray:
-      msgpack_rpc_free_tabpagearray(value.data.tabpagearray);
-      break;
-
     case kObjectTypeDictionary:
       msgpack_rpc_free_dictionary(value.data.dictionary);
       break;
@@ -374,9 +306,3 @@ void msgpack_rpc_free_dictionary(Dictionary value)
 REMOTE_FUNCS_IMPL(Buffer, buffer)
 REMOTE_FUNCS_IMPL(Window, window)
 REMOTE_FUNCS_IMPL(Tabpage, tabpage)
-
-TYPED_ARRAY_IMPL(Buffer, buffer)
-TYPED_ARRAY_IMPL(Window, window)
-TYPED_ARRAY_IMPL(Tabpage, tabpage)
-TYPED_ARRAY_IMPL(String, string)
-
diff --git a/src/nvim/os/msgpack_rpc_helpers.h b/src/nvim/os/msgpack_rpc_helpers.h
index e3d1e756ef..f4d01faa09 100644
--- a/src/nvim/os/msgpack_rpc_helpers.h
+++ b/src/nvim/os/msgpack_rpc_helpers.h
@@ -34,14 +34,6 @@ bool msgpack_rpc_to_tabpage(msgpack_object *obj, Tabpage *arg)
   FUNC_ATTR_NONNULL_ALL;
 bool msgpack_rpc_to_object(msgpack_object *obj, Object *arg)
   FUNC_ATTR_NONNULL_ALL;
-bool msgpack_rpc_to_stringarray(msgpack_object *obj, StringArray *arg)
-  FUNC_ATTR_NONNULL_ALL;
-bool msgpack_rpc_to_bufferarray(msgpack_object *obj, BufferArray *arg)
-  FUNC_ATTR_NONNULL_ALL;
-bool msgpack_rpc_to_windowarray(msgpack_object *obj, WindowArray *arg)
-  FUNC_ATTR_NONNULL_ALL;
-bool msgpack_rpc_to_tabpagearray(msgpack_object *obj, TabpageArray *arg)
-  FUNC_ATTR_NONNULL_ALL;
 bool msgpack_rpc_to_array(msgpack_object *obj, Array *arg)
   FUNC_ATTR_NONNULL_ALL;
 bool msgpack_rpc_to_dictionary(msgpack_object *obj, Dictionary *arg)
@@ -71,14 +63,6 @@ void msgpack_rpc_from_tabpage(Tabpage result, msgpack_packer *res)
   FUNC_ATTR_NONNULL_ARG(2);
 void msgpack_rpc_from_object(Object result, msgpack_packer *res)
   FUNC_ATTR_NONNULL_ARG(2);
-void msgpack_rpc_from_stringarray(StringArray result, msgpack_packer *res)
-  FUNC_ATTR_NONNULL_ARG(2);
-void msgpack_rpc_from_bufferarray(BufferArray result, msgpack_packer *res)
-  FUNC_ATTR_NONNULL_ARG(2);
-void msgpack_rpc_from_windowarray(WindowArray result, msgpack_packer *res)
-  FUNC_ATTR_NONNULL_ARG(2);
-void msgpack_rpc_from_tabpagearray(TabpageArray result, msgpack_packer *res)
-  FUNC_ATTR_NONNULL_ARG(2);
 void msgpack_rpc_from_array(Array result, msgpack_packer *res)
   FUNC_ATTR_NONNULL_ARG(2);
 void msgpack_rpc_from_dictionary(Dictionary result, msgpack_packer *res)
@@ -113,10 +97,6 @@ void msgpack_rpc_free_string(String value);
 #define msgpack_rpc_free_window(value)
 #define msgpack_rpc_free_tabpage(value)
 void msgpack_rpc_free_object(Object value);
-void msgpack_rpc_free_stringarray(StringArray value);
-void msgpack_rpc_free_bufferarray(BufferArray value);
-void msgpack_rpc_free_windowarray(WindowArray value);
-void msgpack_rpc_free_tabpagearray(TabpageArray value);
 void msgpack_rpc_free_array(Array value);
 void msgpack_rpc_free_dictionary(Dictionary value);