API: Refactor: Return handles instead of indexes

- Define specialized arrays for each remote object type
- Implement msgpack_rpc functions for dealing with the new types
- Refactor all functions dealing with buffers, windows and tabpages to
  return/accept handles instead of list indexes.

src/nvim/api/private/defs.h

@@ -34,6 +34,9 @@ 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 {

src/nvim/api/private/helpers.c

@@ -4,6 +4,7 @@
 
 #include "nvim/api/private/helpers.h"
 #include "nvim/api/private/defs.h"
+#include "nvim/api/private/handle.h"
 #include "nvim/vim.h"
 #include "nvim/buffer.h"
 #include "nvim/window.h"
@@ -285,43 +286,29 @@ Object vim_to_object(typval_T *obj)
 
 buf_T *find_buffer(Buffer buffer, Error *err)
 {
-  if (buffer > INT_MAX) {
+  buf_T *rv = handle_get_buffer(buffer);
-    set_api_error("Invalid buffer id", err);
-    return NULL;
-  }
 
-  buf_T *buf = buflist_findnr((int)buffer);
+  if (!rv) {
-
-  if (buf == NULL) {
     set_api_error("Invalid buffer id", err);
   }
 
-  return buf;
+  return rv;
 }
 
 win_T * find_window(Window window, Error *err)
 {
-  tabpage_T *tp;
+  win_T *rv = handle_get_window(window);
-  win_T *wp;
 
-  FOR_ALL_TAB_WINDOWS(tp, wp) {
+  if (!rv) {
-    if (!--window) {
+    set_api_error("Invalid window id", err);
-      return wp;
-    }
   }
 
-  set_api_error("Invalid window id", err);
+  return rv;
-  return NULL;
 }
 
 tabpage_T * find_tab(Tabpage tabpage, Error *err)
 {
-  if (tabpage > INT_MAX) {
+  tabpage_T *rv = handle_get_tabpage(tabpage);
-    set_api_error("Invalid tabpage id", err);
-    return NULL;
-  }
-
-  tabpage_T *rv = find_tabpage((int)tabpage);
 
   if (!rv) {
     set_api_error("Invalid tabpage id", err);

src/nvim/api/tabpage.c

@@ -6,10 +6,11 @@
 #include "nvim/api/vim.h"
 #include "nvim/api/private/defs.h"
 #include "nvim/api/private/helpers.h"
+#include "nvim/memory.h"
 
-Integer tabpage_get_window_count(Tabpage tabpage, Error *err)
+WindowArray tabpage_get_windows(Tabpage tabpage, Error *err)
 {
-  Integer rv = 0;
+  WindowArray rv = {.size = 0};
   tabpage_T *tab = find_tab(tabpage, err);
 
   if (!tab) {
@@ -23,7 +24,17 @@ Integer tabpage_get_window_count(Tabpage tabpage, Error *err)
     if (tp != tab) {
       break;
     }
-    rv++;
+    rv.size++;
+  }
+
+  rv.items = xmalloc(sizeof(Window) * rv.size);
+  size_t i = 0;
+
+  FOR_ALL_TAB_WINDOWS(tp, wp) {
+    if (tp != tab) {
+      break;
+    }
+    rv.items[i++] = wp->handle;
   }
 
   return rv;
@@ -67,13 +78,11 @@ Window tabpage_get_window(Tabpage tabpage, Error *err)
   } else {
     tabpage_T *tp;
     win_T *wp;
-    rv = 1;
 
     FOR_ALL_TAB_WINDOWS(tp, wp) {
       if (tp == tab && wp == tab->tp_curwin) {
-        return rv;
+        return wp->handle;
       }
-      rv++;
     }
     // There should always be a current window for a tabpage
     abort();

src/nvim/api/tabpage.h

@@ -11,7 +11,7 @@
 /// @param tabpage The tabpage
 /// @param[out] err Details of an error that may have occurred
 /// @return The number of windows in `tabpage`
-Integer tabpage_get_window_count(Tabpage tabpage, Error *err);
+WindowArray tabpage_get_windows(Tabpage tabpage, Error *err);
 
 /// Gets a tabpage variable
 ///

src/nvim/api/vim.c

@@ -142,27 +142,17 @@ void vim_change_directory(String dir, Error *err)
 
 String vim_get_current_line(Error *err)
 {
-  assert(curbuf->b_fnum >= 0);
+  return buffer_get_line(curbuf->handle, curwin->w_cursor.lnum - 1, err);
-  return buffer_get_line((uint64_t)curbuf->b_fnum,
-                         curwin->w_cursor.lnum - 1,
-                         err);
 }
 
 void vim_set_current_line(String line, Error *err)
 {
-  assert(curbuf->b_fnum >= 0);
+  buffer_set_line(curbuf->handle, curwin->w_cursor.lnum - 1, line, err);
-  buffer_set_line((uint64_t)curbuf->b_fnum,
-                  curwin->w_cursor.lnum - 1,
-                  line,
-                  err);
 }
 
 void vim_del_current_line(Error *err)
 {
-  assert(curbuf->b_fnum >= 0);
+  buffer_del_line(curbuf->handle, curwin->w_cursor.lnum - 1, err);
-  buffer_del_line((uint64_t)curbuf->b_fnum,
-                  curwin->w_cursor.lnum - 1,
-                  err);
 }
 
 Object vim_get_var(String name, Error *err)
@@ -200,33 +190,43 @@ void vim_err_write(String str)
   write_msg(str, true);
 }
 
-Integer vim_get_buffer_count(void)
+BufferArray vim_get_buffers(void)
 {
+  BufferArray rv = {.size = 0};
   buf_T *b = firstbuf;
-  Integer n = 0;
 
   while (b) {
-    n++;
+    rv.size++;
     b = b->b_next;
   }
 
-  return n;
+  rv.items = xmalloc(sizeof(Buffer) * rv.size);
+  size_t i = 0;
+  b = firstbuf;
+
+  while (b) {
+    rv.items[i++] = b->handle;
+    b = b->b_next;
+  }
+
+  return rv;
 }
 
 Buffer vim_get_current_buffer(void)
 {
-  assert(curbuf->b_fnum >= 0);
+  return curbuf->handle;
-  return (uint64_t)curbuf->b_fnum;
 }
 
 void vim_set_current_buffer(Buffer buffer, Error *err)
 {
-  if (!find_buffer(buffer, err)) {
+  buf_T *buf = find_buffer(buffer, err);
+
+  if (!buf) {
     return;
   }
 
   try_start();
-  if (do_buffer(DOBUF_GOTO, DOBUF_FIRST, FORWARD, (int)buffer, 0) == FAIL) {
+  if (do_buffer(DOBUF_GOTO, DOBUF_FIRST, FORWARD, buf->b_fnum, 0) == FAIL) {
     if (try_end(err)) {
       return;
     }
@@ -240,14 +240,21 @@ void vim_set_current_buffer(Buffer buffer, Error *err)
   try_end(err);
 }
 
-Integer vim_get_window_count(void)
+WindowArray vim_get_windows(void)
 {
+  WindowArray rv = {.size = 0};
   tabpage_T *tp;
   win_T *wp;
-  Integer rv = 0;
 
   FOR_ALL_TAB_WINDOWS(tp, wp) {
-    rv++;
+    rv.size++;
+  }
+
+  rv.items = xmalloc(sizeof(Window) * rv.size);
+  size_t i = 0;
+
+  FOR_ALL_TAB_WINDOWS(tp, wp) {
+    rv.items[i++] = wp->handle;
   }
 
   return rv;
@@ -255,20 +262,7 @@ Integer vim_get_window_count(void)
 
 Window vim_get_current_window(void)
 {
-  tabpage_T *tp;
+  return curwin->handle;
-  win_T *wp;
-  Window rv = 1;
-
-  FOR_ALL_TAB_WINDOWS(tp, wp) {
-    if (wp == curwin) {
-      return rv;
-    }
-
-    rv++;
-  }
-
-  // There should always be a current window
-  abort();
 }
 
 void vim_set_current_window(Window window, Error *err)
@@ -280,7 +274,7 @@ void vim_set_current_window(Window window, Error *err)
   }
 
   try_start();
-  win_goto(win);
+  goto_tabpage_win(win_find_tabpage(win), win);
 
   if (win != curwin) {
     if (try_end(err)) {
@@ -293,14 +287,23 @@ void vim_set_current_window(Window window, Error *err)
   try_end(err);
 }
 
-Integer vim_get_tabpage_count(void)
+TabpageArray vim_get_tabpages(void)
 {
+  TabpageArray rv = {.size = 0};
   tabpage_T *tp = first_tabpage;
-  Integer rv = 0;
 
-  while (tp != NULL) {
+  while (tp) {
+    rv.size++;
+    tp = tp->tp_next;
+  }
+
+  rv.items = xmalloc(sizeof(Tabpage) * rv.size);
+  size_t i = 0;
+  tp = first_tabpage;
+
+  while (tp) {
+    rv.items[i++] = tp->handle;
     tp = tp->tp_next;
-    rv++;
   }
 
   return rv;
@@ -308,24 +311,19 @@ Integer vim_get_tabpage_count(void)
 
 Tabpage vim_get_current_tabpage(void)
 {
-  Tabpage rv = 1;
+  return curtab->handle;
-  tabpage_T *t;
-
-  for (t = first_tabpage; t != NULL && t != curtab; t = t->tp_next) {
-    rv++;
-  }
-
-  return rv;
 }
 
 void vim_set_current_tabpage(Tabpage tabpage, Error *err)
 {
-  if (!find_tab(tabpage, err)) {
+  tabpage_T *tp = find_tab(tabpage, err);
+
+  if (!tp) {
     return;
   }
 
   try_start();
-  goto_tabpage((int)tabpage);
+  goto_tabpage_tp(tp, true, true);
   try_end(err);
 }
 

src/nvim/api/vim.h

@@ -108,10 +108,10 @@ void vim_out_write(String str);
 /// @param str The message
 void vim_err_write(String str);
 
-/// Gets the number of buffers
+/// Gets the current list of buffer handles
 ///
 /// @return The number of buffers
-Integer vim_get_buffer_count(void);
+BufferArray vim_get_buffers(void);
 
 /// Return the current buffer
 ///
@@ -124,10 +124,10 @@ Buffer vim_get_current_buffer(void);
 /// @param[out] err Details of an error that may have occurred
 void vim_set_current_buffer(Buffer buffer, Error *err);
 
-/// Gets the number of windows
+/// Gets the current list of window handles
 ///
 /// @return The number of windows
-Integer vim_get_window_count(void);
+WindowArray vim_get_windows(void);
 
 /// Return the current window
 ///
@@ -139,10 +139,10 @@ Window vim_get_current_window(void);
 /// @param handle The window handle
 void vim_set_current_window(Window window, Error *err);
 
-/// Gets the number of tab pages
+/// Gets the current list of tabpage handles
 ///
 /// @return The number of tab pages
-Integer vim_get_tabpage_count(void);
+TabpageArray vim_get_tabpages(void);
 
 /// Return the current tab page
 ///

src/nvim/api/window.c

@@ -19,8 +19,7 @@ Buffer window_get_buffer(Window window, Error *err)
     return 0;
   }
 
-  assert(win->w_buffer->b_fnum >= 0);
+  return win->w_buffer->handle;
-  return (uint64_t)win->w_buffer->b_fnum;
 }
 
 Position window_get_cursor(Window window, Error *err)
@@ -193,8 +192,14 @@ Position window_get_position(Window window, Error *err)
 
 Tabpage window_get_tabpage(Window window, Error *err)
 {
-  set_api_error("Not implemented", err);
+  Tabpage rv = 0;
-  return 0;
+  win_T *win = find_window(window, err);
+
+  if (win) {
+    rv = win_find_tabpage(win)->handle;
+  }
+
+  return rv;
 }
 
 Boolean window_is_valid(Window window)

src/nvim/os/msgpack_rpc.c

@@ -377,5 +377,8 @@ 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)
 

src/nvim/os/msgpack_rpc.h

@@ -50,6 +50,9 @@ bool msgpack_rpc_to_window(msgpack_object *obj, Window *arg);
 bool msgpack_rpc_to_tabpage(msgpack_object *obj, Tabpage *arg);
 bool msgpack_rpc_to_object(msgpack_object *obj, Object *arg);
 bool msgpack_rpc_to_stringarray(msgpack_object *obj, StringArray *arg);
+bool msgpack_rpc_to_bufferarray(msgpack_object *obj, BufferArray *arg);
+bool msgpack_rpc_to_windowarray(msgpack_object *obj, WindowArray *arg);
+bool msgpack_rpc_to_tabpagearray(msgpack_object *obj, TabpageArray *arg);
 bool msgpack_rpc_to_array(msgpack_object *obj, Array *arg);
 bool msgpack_rpc_to_dictionary(msgpack_object *obj, Dictionary *arg);
 
@@ -69,6 +72,9 @@ void msgpack_rpc_from_window(Window result, msgpack_packer *res);
 void msgpack_rpc_from_tabpage(Tabpage result, msgpack_packer *res);
 void msgpack_rpc_from_object(Object result, msgpack_packer *res);
 void msgpack_rpc_from_stringarray(StringArray result, msgpack_packer *res);
+void msgpack_rpc_from_bufferarray(BufferArray result, msgpack_packer *res);
+void msgpack_rpc_from_windowarray(WindowArray result, msgpack_packer *res);
+void msgpack_rpc_from_tabpagearray(TabpageArray result, msgpack_packer *res);
 void msgpack_rpc_from_array(Array result, msgpack_packer *res);
 void msgpack_rpc_from_dictionary(Dictionary result, msgpack_packer *res);
 
@@ -83,6 +89,9 @@ void msgpack_rpc_from_dictionary(Dictionary result, msgpack_packer *res);
 #define msgpack_rpc_init_tabpage
 #define msgpack_rpc_init_object = {.type = kObjectTypeNil}
 #define msgpack_rpc_init_stringarray = ARRAY_DICT_INIT
+#define msgpack_rpc_init_bufferarray = ARRAY_DICT_INIT
+#define msgpack_rpc_init_windowarray = ARRAY_DICT_INIT
+#define msgpack_rpc_init_tabpagearray = ARRAY_DICT_INIT
 #define msgpack_rpc_init_array = ARRAY_DICT_INIT
 #define msgpack_rpc_init_dictionary = ARRAY_DICT_INIT
 
@@ -101,6 +110,9 @@ void msgpack_rpc_from_dictionary(Dictionary result, msgpack_packer *res);
 #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);