api/msgpack-rpc: Refactor msgpack_rpc_helpers.{c,h}

- Move helpers that are specific to API types to api/private/helpers.{c,h}
- Include headers with generated declarations
- Delete unused macros

scripts/msgpack-gen.lua

@@ -158,7 +158,7 @@ for i = 1, #api.functions do
   for j = 1, #fn.parameters do
     local param = fn.parameters[j]
     local converted = 'arg_'..j
-    output:write('\n  '..param[1]..' '..converted..' msgpack_rpc_init_'..string.lower(param[1])..';')
+    output:write('\n  '..param[1]..' '..converted..' api_init_'..string.lower(param[1])..';')
   end
   output:write('\n')
   output:write('\n  if (req->via.array.ptr[3].via.array.size != '..#fn.parameters..') {')
@@ -228,7 +228,7 @@ for i = 1, #api.functions do
 
   for j = 1, #fn.parameters do
     local param = fn.parameters[j]
-    output:write('\n  msgpack_rpc_free_'..string.lower(param[1])..'(arg_'..j..');')
+    output:write('\n  api_free_'..string.lower(param[1])..'(arg_'..j..');')
   end
   if fn.return_type ~= 'void' then
     output:write('\n  return ret;\n}\n\n');

src/nvim/api/private/helpers.c

@@ -449,6 +449,64 @@ bool object_to_vim(Object obj, typval_T *tv, Error *err)
   return true;
 }
 
+void api_free_string(String value)
+{
+  if (!value.data) {
+    return;
+  }
+
+  free(value.data);
+}
+
+void api_free_object(Object value)
+{
+  switch (value.type) {
+    case kObjectTypeNil:
+    case kObjectTypeBoolean:
+    case kObjectTypeInteger:
+    case kObjectTypeFloat:
+    case kObjectTypeBuffer:
+    case kObjectTypeWindow:
+    case kObjectTypeTabpage:
+      break;
+
+    case kObjectTypeString:
+      api_free_string(value.data.string);
+      break;
+
+    case kObjectTypeArray:
+      api_free_array(value.data.array);
+      break;
+
+    case kObjectTypeDictionary:
+      api_free_dictionary(value.data.dictionary);
+      break;
+
+    default:
+      abort();
+  }
+}
+
+void api_free_array(Array value)
+{
+  for (size_t i = 0; i < value.size; i++) {
+    api_free_object(value.items[i]);
+  }
+
+  free(value.items);
+}
+
+void api_free_dictionary(Dictionary value)
+{
+  for (size_t i = 0; i < value.size; i++) {
+    api_free_string(value.items[i].key);
+    api_free_object(value.items[i].value);
+  }
+
+  free(value.items);
+}
+
+
 /// Recursion helper for the `vim_to_object`. This uses a pointer table
 /// to avoid infinite recursion due to cyclic references
 ///

src/nvim/api/private/helpers.h

@@ -51,36 +51,11 @@
   .data.array = a                                                             \
   })
 
-#define STRINGARRAY_OBJ(a) ((Object) {                                        \
-  .type = kObjectTypeStringArray,                                             \
-  .data.stringarray = a                                                       \
-  })
-
-#define BUFFERARRAY_OBJ(a) ((Object) {                                        \
-  .type = kObjectTypeBufferArray,                                             \
-  .data.bufferarray = a                                                       \
-  })
-
-#define WINDOWARRAY_OBJ(a) ((Object) {                                        \
-  .type = kObjectTypeWindowArray,                                             \
-  .data.windowarray = a                                                       \
-  })
-
-#define TABPAGEARRAY_OBJ(a) ((Object) {                                       \
-  .type = kObjectTypeTabpageArray,                                            \
-  .data.tabpagearray = a                                                      \
-  })
-
 #define DICTIONARY_OBJ(d) ((Object) {                                         \
   .type = kObjectTypeDictionary,                                              \
   .data.dictionary = d                                                        \
   })
 
-#define POSITION_OBJ(p) ((Object) {                                           \
-  .type = kObjectTypePosition,                                                \
-  .data.position = p                                                          \
-  })
-
 #define NIL ((Object) {.type = kObjectTypeNil})
 
 #define PUT(dict, k, v)                                                       \
@@ -91,6 +66,25 @@
 #define ADD(array, item)                                                      \
   kv_push(Object, array, item)
 
+// Helpers used by the generated msgpack-rpc api wrappers
+#define api_init_boolean
+#define api_init_integer
+#define api_init_float
+#define api_init_string = STRING_INIT
+#define api_init_buffer
+#define api_init_window
+#define api_init_tabpage
+#define api_init_object = NIL
+#define api_init_array = ARRAY_DICT_INIT
+#define api_init_dictionary = ARRAY_DICT_INIT
+
+#define api_free_boolean(value)
+#define api_free_integer(value)
+#define api_free_float(value)
+#define api_free_buffer(value)
+#define api_free_window(value)
+#define api_free_tabpage(value)
+
 #ifdef INCLUDE_GENERATED_DECLARATIONS
 # include "api/private/helpers.h.generated.h"
 #endif

src/nvim/eval.c

@@ -84,7 +84,6 @@
 #include "nvim/os/channel.h"
 #include "nvim/api/private/helpers.h"
 #include "nvim/api/vim.h"
-#include "nvim/os/msgpack_rpc_helpers.h"
 #include "nvim/os/dl.h"
 #include "nvim/os/provider.h"
 
@@ -12725,7 +12724,7 @@ static void f_send_call(typval_T *argvars, typval_T *rettv)
         _("Error converting the call result"));
   }
 
-  msgpack_rpc_free_object(result);
+  api_free_object(result);
 }
 
 // "send_event()" function
@@ -19239,7 +19238,7 @@ static void script_host_eval(char *method, typval_T *argvars, typval_T *rettv)
 
   Error err = {.set = false};
   object_to_vim(result, rettv, &err);
-  msgpack_rpc_free_object(result);
+  api_free_object(result);
 
   if (err.set) {
     EMSG("Error converting value back to vim");

src/nvim/ex_cmds2.c

@@ -55,7 +55,6 @@
 #include "nvim/os/shell.h"
 #include "nvim/os/fs_defs.h"
 #include "nvim/os/provider.h"
-#include "nvim/os/msgpack_rpc_helpers.h"
 #include "nvim/api/private/helpers.h"
 #include "nvim/api/private/defs.h"
 
@@ -3264,7 +3263,7 @@ static void script_host_execute(char *method, exarg_T *eap)
     Object result = provider_call(method, args);
     // We don't care about the result, so free it just in case a bad provider
     // returned something
-    msgpack_rpc_free_object(result);
+    api_free_object(result);
   }
 
   free(script);
@@ -3278,7 +3277,7 @@ static void script_host_execute_file(char *method, exarg_T *eap)
   Array args = ARRAY_DICT_INIT;
   ADD(args, STRING_OBJ(cstr_to_string(buffer)));
   Object result = provider_call(method, args);
-  msgpack_rpc_free_object(result);
+  api_free_object(result);
 }
 
 static void script_host_do_range(char *method, exarg_T *eap)
@@ -3288,6 +3287,6 @@ static void script_host_do_range(char *method, exarg_T *eap)
   ADD(args, INTEGER_OBJ(eap->line2));
   ADD(args, STRING_OBJ(cstr_to_string((char *)eap->arg)));
   Object result = provider_call(method, args);
-  msgpack_rpc_free_object(result);
+  api_free_object(result);
 }
 

src/nvim/ops.c

@@ -48,7 +48,6 @@
 #include "nvim/undo.h"
 #include "nvim/window.h"
 #include "nvim/os/provider.h"
-#include "nvim/os/msgpack_rpc_helpers.h"
 #include "nvim/api/private/helpers.h"
 
 /*
@@ -5256,7 +5255,7 @@ static void get_clipboard(int name)
   return;
 
 err:
-  msgpack_rpc_free_object(result);
+  api_free_object(result);
   free(reg->y_array);
   reg->y_array = NULL;
   reg->y_size = 0;
@@ -5287,5 +5286,5 @@ static void set_clipboard(int name)
   ADD(args, ARRAY_OBJ(lines));
 
   Object result = provider_call("clipboard_set", args);
-  msgpack_rpc_free_object(result);
+  api_free_object(result);
 }

src/nvim/os/channel.c

@@ -158,7 +158,7 @@ bool channel_send_event(uint64_t id, char *name, Array args)
 
   if (id > 0) {
     if (!(channel = pmap_get(uint64_t)(channels, id)) || !channel->enabled) {
-      msgpack_rpc_free_array(args);
+      api_free_array(args);
       return false;
     }
     send_event(channel, name, args);
@@ -186,7 +186,7 @@ bool channel_send_call(uint64_t id,
   Channel *channel = NULL;
 
   if (!(channel = pmap_get(uint64_t)(channels, id)) || !channel->enabled) {
-    msgpack_rpc_free_array(args);
+    api_free_array(args);
     return false;
   }
 
@@ -199,7 +199,7 @@ bool channel_send_call(uint64_t id,
         "Channel %" PRIu64 " crossed maximum stack depth",
         channel->id);
     *result = STRING_OBJ(cstr_to_string(buf));
-    msgpack_rpc_free_array(args);
+    api_free_array(args);
     return false;
   }
 
@@ -448,7 +448,7 @@ static void broadcast_event(char *name, Array args)
   });
 
   if (!kv_size(subscribed)) {
-    msgpack_rpc_free_array(args);
+    api_free_array(args);
     goto end;
   }
 

src/nvim/os/msgpack_rpc.c

@@ -120,7 +120,7 @@ WBuffer *serialize_request(uint64_t request_id,
                                    sbuffer->size,
                                    refcount,
                                    free);
-  msgpack_rpc_free_array(args);
+  api_free_array(args);
   msgpack_sbuffer_clear(sbuffer);
   return rv;
 }
@@ -156,7 +156,7 @@ WBuffer *serialize_response(uint64_t response_id,
                                    sbuffer->size,
                                    1,  // responses only go though 1 channel
                                    free);
-  msgpack_rpc_free_object(arg);
+  api_free_object(arg);
   msgpack_sbuffer_clear(sbuffer);
   return rv;
 }

src/nvim/os/msgpack_rpc_helpers.c

@@ -7,11 +7,16 @@
 #include "nvim/vim.h"
 #include "nvim/memory.h"
 
+#ifdef INCLUDE_GENERATED_DECLARATIONS
+# include "os/msgpack_rpc_helpers.c.generated.h"
+#endif
+
 static msgpack_zone zone;
 static msgpack_sbuffer sbuffer;
 
 #define HANDLE_TYPE_CONVERSION_IMPL(t, lt)                                  \
   bool msgpack_rpc_to_##lt(msgpack_object *obj, t *arg)                     \
+    FUNC_ATTR_NONNULL_ALL                                                   \
   {                                                                         \
     if (obj->type != MSGPACK_OBJECT_EXT                                     \
         || obj->via.ext.type != kObjectType##t) {                           \
@@ -34,6 +39,7 @@ static msgpack_sbuffer sbuffer;
   }                                                                         \
                                                                             \
   void msgpack_rpc_from_##lt(t o, msgpack_packer *res)                      \
+    FUNC_ATTR_NONNULL_ARG(2)                                                \
   {                                                                         \
     msgpack_packer pac;                                                     \
     msgpack_packer_init(&pac, &sbuffer, msgpack_sbuffer_write);             \
@@ -49,13 +55,19 @@ void msgpack_rpc_helpers_init(void)
   msgpack_sbuffer_init(&sbuffer);
 }
 
+HANDLE_TYPE_CONVERSION_IMPL(Buffer, buffer)
+HANDLE_TYPE_CONVERSION_IMPL(Window, window)
+HANDLE_TYPE_CONVERSION_IMPL(Tabpage, tabpage)
+
 bool msgpack_rpc_to_boolean(msgpack_object *obj, Boolean *arg)
+  FUNC_ATTR_NONNULL_ALL
 {
   *arg = obj->via.boolean;
   return obj->type == MSGPACK_OBJECT_BOOLEAN;
 }
 
 bool msgpack_rpc_to_integer(msgpack_object *obj, Integer *arg)
+  FUNC_ATTR_NONNULL_ALL
 {
   if (obj->type == MSGPACK_OBJECT_POSITIVE_INTEGER
       && obj->via.u64 <= INT64_MAX) {
@@ -68,12 +80,14 @@ bool msgpack_rpc_to_integer(msgpack_object *obj, Integer *arg)
 }
 
 bool msgpack_rpc_to_float(msgpack_object *obj, Float *arg)
+  FUNC_ATTR_NONNULL_ALL
 {
   *arg = obj->via.dec;
   return obj->type == MSGPACK_OBJECT_DOUBLE;
 }
 
 bool msgpack_rpc_to_string(msgpack_object *obj, String *arg)
+  FUNC_ATTR_NONNULL_ALL
 {
   if (obj->type == MSGPACK_OBJECT_BIN || obj->type == MSGPACK_OBJECT_STR) {
     arg->data = xmemdupz(obj->via.bin.ptr, obj->via.bin.size);
@@ -86,6 +100,7 @@ bool msgpack_rpc_to_string(msgpack_object *obj, String *arg)
 }
 
 bool msgpack_rpc_to_object(msgpack_object *obj, Object *arg)
+  FUNC_ATTR_NONNULL_ALL
 {
   switch (obj->type) {
     case MSGPACK_OBJECT_NIL:
@@ -133,6 +148,7 @@ bool msgpack_rpc_to_object(msgpack_object *obj, Object *arg)
 }
 
 bool msgpack_rpc_to_array(msgpack_object *obj, Array *arg)
+  FUNC_ATTR_NONNULL_ALL
 {
   if (obj->type != MSGPACK_OBJECT_ARRAY) {
     return false;
@@ -151,6 +167,7 @@ bool msgpack_rpc_to_array(msgpack_object *obj, Array *arg)
 }
 
 bool msgpack_rpc_to_dictionary(msgpack_object *obj, Dictionary *arg)
+  FUNC_ATTR_NONNULL_ALL
 {
   if (obj->type != MSGPACK_OBJECT_MAP) {
     return false;
@@ -176,6 +193,7 @@ bool msgpack_rpc_to_dictionary(msgpack_object *obj, Dictionary *arg)
 }
 
 void msgpack_rpc_from_boolean(Boolean result, msgpack_packer *res)
+  FUNC_ATTR_NONNULL_ARG(2)
 {
   if (result) {
     msgpack_pack_true(res);
@@ -185,22 +203,26 @@ void msgpack_rpc_from_boolean(Boolean result, msgpack_packer *res)
 }
 
 void msgpack_rpc_from_integer(Integer result, msgpack_packer *res)
+  FUNC_ATTR_NONNULL_ARG(2)
 {
   msgpack_pack_int64(res, result);
 }
 
 void msgpack_rpc_from_float(Float result, msgpack_packer *res)
+  FUNC_ATTR_NONNULL_ARG(2)
 {
   msgpack_pack_double(res, result);
 }
 
 void msgpack_rpc_from_string(String result, msgpack_packer *res)
+  FUNC_ATTR_NONNULL_ARG(2)
 {
   msgpack_pack_bin(res, result.size);
   msgpack_pack_bin_body(res, result.data, result.size);
 }
 
 void msgpack_rpc_from_object(Object result, msgpack_packer *res)
+  FUNC_ATTR_NONNULL_ARG(2)
 {
   switch (result.type) {
     case kObjectTypeNil:
@@ -246,6 +268,7 @@ void msgpack_rpc_from_object(Object result, msgpack_packer *res)
 }
 
 void msgpack_rpc_from_array(Array result, msgpack_packer *res)
+  FUNC_ATTR_NONNULL_ARG(2)
 {
   msgpack_pack_array(res, result.size);
 
@@ -255,6 +278,7 @@ void msgpack_rpc_from_array(Array result, msgpack_packer *res)
 }
 
 void msgpack_rpc_from_dictionary(Dictionary result, msgpack_packer *res)
+  FUNC_ATTR_NONNULL_ARG(2)
 {
   msgpack_pack_map(res, result.size);
 
@@ -263,64 +287,3 @@ void msgpack_rpc_from_dictionary(Dictionary result, msgpack_packer *res)
     msgpack_rpc_from_object(result.items[i].value, res);
   }
 }
-
-void msgpack_rpc_free_string(String value)
-{
-  if (!value.data) {
-    return;
-  }
-
-  free(value.data);
-}
-
-void msgpack_rpc_free_object(Object value)
-{
-  switch (value.type) {
-    case kObjectTypeNil:
-    case kObjectTypeBoolean:
-    case kObjectTypeInteger:
-    case kObjectTypeFloat:
-    case kObjectTypeBuffer:
-    case kObjectTypeWindow:
-    case kObjectTypeTabpage:
-      break;
-
-    case kObjectTypeString:
-      msgpack_rpc_free_string(value.data.string);
-      break;
-
-    case kObjectTypeArray:
-      msgpack_rpc_free_array(value.data.array);
-      break;
-
-    case kObjectTypeDictionary:
-      msgpack_rpc_free_dictionary(value.data.dictionary);
-      break;
-
-    default:
-      abort();
-  }
-}
-
-void msgpack_rpc_free_array(Array value)
-{
-  for (uint32_t i = 0; i < value.size; i++) {
-    msgpack_rpc_free_object(value.items[i]);
-  }
-
-  free(value.items);
-}
-
-void msgpack_rpc_free_dictionary(Dictionary value)
-{
-  for (uint32_t i = 0; i < value.size; i++) {
-    msgpack_rpc_free_string(value.items[i].key);
-    msgpack_rpc_free_object(value.items[i].value);
-  }
-
-  free(value.items);
-}
-
-HANDLE_TYPE_CONVERSION_IMPL(Buffer, buffer)
-HANDLE_TYPE_CONVERSION_IMPL(Window, window)
-HANDLE_TYPE_CONVERSION_IMPL(Tabpage, tabpage)

src/nvim/os/msgpack_rpc_helpers.h

@@ -6,97 +6,11 @@
 
 #include <msgpack.h>
 
-#include "nvim/func_attr.h"
 #include "nvim/api/private/defs.h"
 
-void msgpack_rpc_helpers_init(void);
+#ifdef INCLUDE_GENERATED_DECLARATIONS
-
+# include "os/msgpack_rpc_helpers.h.generated.h"
-/// Functions for validating and converting from msgpack types to C types.
+#endif
-/// These are used by `msgpack_rpc_dispatch` to validate and convert each
-/// argument.
-///
-/// @param obj The object to convert
-/// @param[out] arg A pointer to the avalue
-/// @return true if the conversion succeeded, false otherwise
-bool msgpack_rpc_to_boolean(msgpack_object *obj, Boolean *arg)
-  FUNC_ATTR_NONNULL_ALL;
-bool msgpack_rpc_to_integer(msgpack_object *obj, Integer *arg)
-  FUNC_ATTR_NONNULL_ALL;
-bool msgpack_rpc_to_float(msgpack_object *obj, Float *arg)
-  FUNC_ATTR_NONNULL_ALL;
-bool msgpack_rpc_to_string(msgpack_object *obj, String *arg)
-  FUNC_ATTR_NONNULL_ALL;
-bool msgpack_rpc_to_buffer(msgpack_object *obj, Buffer *arg)
-  FUNC_ATTR_NONNULL_ALL;
-bool msgpack_rpc_to_window(msgpack_object *obj, Window *arg)
-  FUNC_ATTR_NONNULL_ALL;
-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_array(msgpack_object *obj, Array *arg)
-  FUNC_ATTR_NONNULL_ALL;
-bool msgpack_rpc_to_dictionary(msgpack_object *obj, Dictionary *arg)
-  FUNC_ATTR_NONNULL_ALL;
-
-/// Functions for converting from C types to msgpack types.
-/// These are used by `msgpack_rpc_dispatch` to convert return values
-/// from the API
-///
-/// @param result A pointer to the result
-/// @param res A packer that contains the response
-void msgpack_rpc_from_boolean(Boolean result, msgpack_packer *res)
-  FUNC_ATTR_NONNULL_ARG(2);
-void msgpack_rpc_from_integer(Integer result, msgpack_packer *res)
-  FUNC_ATTR_NONNULL_ARG(2);
-void msgpack_rpc_from_float(Float result, msgpack_packer *res)
-  FUNC_ATTR_NONNULL_ARG(2);
-void msgpack_rpc_from_string(String result, msgpack_packer *res)
-  FUNC_ATTR_NONNULL_ARG(2);
-void msgpack_rpc_from_buffer(Buffer result, msgpack_packer *res)
-  FUNC_ATTR_NONNULL_ARG(2);
-void msgpack_rpc_from_window(Window result, msgpack_packer *res)
-  FUNC_ATTR_NONNULL_ARG(2);
-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_array(Array result, msgpack_packer *res)
-  FUNC_ATTR_NONNULL_ARG(2);
-void msgpack_rpc_from_dictionary(Dictionary result, msgpack_packer *res)
-  FUNC_ATTR_NONNULL_ARG(2);
-
-/// Helpers for initializing types that may be freed later
-#define msgpack_rpc_init_boolean
-#define msgpack_rpc_init_integer
-#define msgpack_rpc_init_float
-#define msgpack_rpc_init_position
-#define msgpack_rpc_init_string = STRING_INIT
-#define msgpack_rpc_init_buffer
-#define msgpack_rpc_init_window
-#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
-
-/// Helpers for freeing arguments/return value
-///
-/// @param value The value to be freed
-#define msgpack_rpc_free_boolean(value)
-#define msgpack_rpc_free_integer(value)
-#define msgpack_rpc_free_float(value)
-#define msgpack_rpc_free_position(value)
-void msgpack_rpc_free_string(String value);
-#define msgpack_rpc_free_buffer(value)
-#define msgpack_rpc_free_window(value)
-#define msgpack_rpc_free_tabpage(value)
-void msgpack_rpc_free_object(Object value);
-void msgpack_rpc_free_array(Array value);
-void msgpack_rpc_free_dictionary(Dictionary value);
 
 #endif  // NVIM_OS_MSGPACK_RPC_HELPERS_H
 

src/nvim/os/provider.c

@@ -14,7 +14,6 @@
 #include "nvim/log.h"
 #include "nvim/map.h"
 #include "nvim/message.h"
-#include "nvim/os/msgpack_rpc_helpers.h"
 
 #define FEATURE_COUNT (sizeof(features) / sizeof(features[0]))
 
@@ -109,7 +108,7 @@ Object provider_call(char *method, Array args)
              "Provider for \"%s\" is not available",
              method);
     report_error(buf);
-    msgpack_rpc_free_array(args);
+    api_free_array(args);
     return NIL;
   }
 
@@ -119,7 +118,7 @@ Object provider_call(char *method, Array args)
 
   if (error) {
     report_error(result.data.string.data);
-    msgpack_rpc_free_object(result);
+    api_free_object(result);
     return NIL;
   }