8 files changed, 639 insertions, 218 deletions

diff --git a/src/nvim/api/private/defs.h b/src/nvim/api/private/defs.h
index fbfa87d5ae..5fb95a163f 100644
--- a/src/nvim/api/private/defs.h
+++ b/src/nvim/api/private/defs.h
@@ -12,8 +12,8 @@
 #define REMOTE_TYPE(type) typedef uint64_t type
 
 #ifdef INCLUDE_GENERATED_DECLARATIONS
-  #define ArrayOf(...) Array
-  #define DictionaryOf(...) Dictionary
+# define ArrayOf(...) Array
+# define DictionaryOf(...) Dictionary
 #endif
 
 // Basic types
@@ -41,6 +41,12 @@ typedef bool Boolean;
 typedef int64_t Integer;
 typedef double Float;
 
+/// Maximum value of an Integer
+#define API_INTEGER_MAX INT64_MAX
+
+/// Minimum value of an Integer
+#define API_INTEGER_MIN INT64_MIN
+
 typedef struct {
   char *data;
   size_t size;
diff --git a/src/nvim/api/private/handle.c b/src/nvim/api/private/handle.c
index abbda95073..69df7294ad 100644
--- a/src/nvim/api/private/handle.c
+++ b/src/nvim/api/private/handle.c
@@ -7,24 +7,24 @@
 
 #define HANDLE_INIT(name) name##_handles = pmap_new(uint64_t)()
 
-#define HANDLE_IMPL(type, name)                                               \
-  static PMap(uint64_t) *name##_handles = NULL;                               \
-                                                                              \
-  type *handle_get_##name(uint64_t handle)                                    \
-  {                                                                           \
-    return pmap_get(uint64_t)(name##_handles, handle);                        \
-  }                                                                           \
-                                                                              \
-  void handle_register_##name(type *name)                                     \
-  {                                                                           \
-    assert(!name->handle);                                                    \
-    name->handle = next_handle++;                                             \
-    pmap_put(uint64_t)(name##_handles, name->handle, name);                   \
-  }                                                                           \
-                                                                              \
-  void handle_unregister_##name(type *name)                                   \
-  {                                                                           \
-    pmap_del(uint64_t)(name##_handles, name->handle);                         \
+#define HANDLE_IMPL(type, name) \
+  static PMap(uint64_t) *name##_handles = NULL; \
+  \
+  type *handle_get_##name(uint64_t handle) \
+  { \
+    return pmap_get(uint64_t)(name##_handles, handle); \
+  } \
+  \
+  void handle_register_##name(type *name) \
+  { \
+    assert(!name->handle); \
+    name->handle = next_handle++; \
+    pmap_put(uint64_t)(name##_handles, name->handle, name); \
+  } \
+  \
+  void handle_unregister_##name(type *name) \
+  { \
+    pmap_del(uint64_t)(name##_handles, name->handle); \
   }
 
 static uint64_t next_handle = 1;
diff --git a/src/nvim/api/private/handle.h b/src/nvim/api/private/handle.h
index 1a196f6797..804e266dc3 100644
--- a/src/nvim/api/private/handle.h
+++ b/src/nvim/api/private/handle.h
@@ -4,9 +4,9 @@
 #include "nvim/vim.h"
 #include "nvim/buffer_defs.h"
 
-#define HANDLE_DECLS(type, name)                                              \
-  type *handle_get_##name(uint64_t handle);                                   \
-  void handle_register_##name(type *name);                                    \
+#define HANDLE_DECLS(type, name) \
+  type *handle_get_##name(uint64_t handle); \
+  void handle_register_##name(type *name); \
   void handle_unregister_##name(type *name);
 
 HANDLE_DECLS(buf_T, buffer)
diff --git a/src/nvim/api/private/helpers.c b/src/nvim/api/private/helpers.c
index db3e499427..c88bf2127a 100644
--- a/src/nvim/api/private/helpers.c
+++ b/src/nvim/api/private/helpers.c
@@ -17,6 +17,13 @@
 #include "nvim/map.h"
 #include "nvim/option.h"
 #include "nvim/option_defs.h"
+#include "nvim/eval/typval_encode.h"
+#include "nvim/lib/kvec.h"
+
+/// Helper structure for vim_to_object
+typedef struct {
+  kvec_t(Object) stack;  ///< Object stack.
+} EncodedData;
 
 #ifdef INCLUDE_GENERATED_DECLARATIONS
 # include "api/private/helpers.c.generated.h"
@@ -310,6 +317,179 @@ void set_option_to(void *to, int type, String name, Object value, Error *err)
   }
 }
 
+#define TYPVAL_ENCODE_ALLOW_SPECIALS false
+
+#define TYPVAL_ENCODE_CONV_NIL() \
+    kv_push(edata->stack, NIL)
+
+#define TYPVAL_ENCODE_CONV_BOOL(num) \
+    kv_push(edata->stack, BOOLEAN_OBJ((Boolean)(num)))
+
+#define TYPVAL_ENCODE_CONV_NUMBER(num) \
+    kv_push(edata->stack, INTEGER_OBJ((Integer)(num)))
+
+#define TYPVAL_ENCODE_CONV_UNSIGNED_NUMBER TYPVAL_ENCODE_CONV_NUMBER
+
+#define TYPVAL_ENCODE_CONV_FLOAT(flt) \
+    kv_push(edata->stack, FLOATING_OBJ((Float)(flt)))
+
+#define TYPVAL_ENCODE_CONV_STRING(str, len) \
+    do { \
+      const size_t len_ = (size_t)(len); \
+      const char *const str_ = (const char *)(str); \
+      assert(len_ == 0 || str_ != NULL); \
+      kv_push(edata->stack, STRING_OBJ(((String) { \
+        .data = xmemdupz((len_?str_:""), len_), \
+        .size = len_ \
+      }))); \
+    } while (0)
+
+#define TYPVAL_ENCODE_CONV_STR_STRING TYPVAL_ENCODE_CONV_STRING
+
+#define TYPVAL_ENCODE_CONV_EXT_STRING(str, len, type) \
+    TYPVAL_ENCODE_CONV_NIL()
+
+#define TYPVAL_ENCODE_CONV_FUNC(fun) \
+    TYPVAL_ENCODE_CONV_NIL()
+
+#define TYPVAL_ENCODE_CONV_EMPTY_LIST() \
+    kv_push(edata->stack, ARRAY_OBJ(((Array) { .capacity = 0, .size = 0 })))
+
+#define TYPVAL_ENCODE_CONV_EMPTY_DICT() \
+    kv_push(edata->stack, \
+            DICTIONARY_OBJ(((Dictionary) { .capacity = 0, .size = 0 })))
+
+static inline void typval_encode_list_start(EncodedData *const edata,
+                                            const size_t len)
+  FUNC_ATTR_ALWAYS_INLINE FUNC_ATTR_NONNULL_ALL
+{
+  const Object obj = OBJECT_INIT;
+  kv_push(edata->stack, ARRAY_OBJ(((Array) {
+    .capacity = len,
+    .size = 0,
+    .items = xmalloc(len * sizeof(*obj.data.array.items)),
+  })));
+}
+
+#define TYPVAL_ENCODE_CONV_LIST_START(len) \
+    typval_encode_list_start(edata, (size_t)(len))
+
+static inline void typval_encode_between_list_items(EncodedData *const edata)
+  FUNC_ATTR_ALWAYS_INLINE FUNC_ATTR_NONNULL_ALL
+{
+  Object item = kv_pop(edata->stack);
+  Object *const list = &kv_last(edata->stack);
+  assert(list->type == kObjectTypeArray);
+  assert(list->data.array.size < list->data.array.capacity);
+  list->data.array.items[list->data.array.size++] = item;
+}
+
+#define TYPVAL_ENCODE_CONV_LIST_BETWEEN_ITEMS() \
+    typval_encode_between_list_items(edata)
+
+static inline void typval_encode_list_end(EncodedData *const edata)
+  FUNC_ATTR_ALWAYS_INLINE FUNC_ATTR_NONNULL_ALL
+{
+  typval_encode_between_list_items(edata);
+#ifndef NDEBUG
+  const Object *const list = &kv_last(edata->stack);
+  assert(list->data.array.size == list->data.array.capacity);
+#endif
+}
+
+#define TYPVAL_ENCODE_CONV_LIST_END() \
+    typval_encode_list_end(edata)
+
+static inline void typval_encode_dict_start(EncodedData *const edata,
+                                            const size_t len)
+  FUNC_ATTR_ALWAYS_INLINE FUNC_ATTR_NONNULL_ALL
+{
+  const Object obj = OBJECT_INIT;
+  kv_push(edata->stack, DICTIONARY_OBJ(((Dictionary) {
+    .capacity = len,
+    .size = 0,
+    .items = xmalloc(len * sizeof(*obj.data.dictionary.items)),
+  })));
+}
+
+#define TYPVAL_ENCODE_CONV_DICT_START(len) \
+    typval_encode_dict_start(edata, (size_t)(len))
+
+#define TYPVAL_ENCODE_CONV_SPECIAL_DICT_KEY_CHECK(label, kv_pair)
+
+static inline void typval_encode_after_key(EncodedData *const edata)
+  FUNC_ATTR_ALWAYS_INLINE FUNC_ATTR_NONNULL_ALL
+{
+  Object key = kv_pop(edata->stack);
+  Object *const dict = &kv_last(edata->stack);
+  assert(dict->type == kObjectTypeDictionary);
+  assert(dict->data.dictionary.size < dict->data.dictionary.capacity);
+  if (key.type == kObjectTypeString) {
+    dict->data.dictionary.items[dict->data.dictionary.size].key
+        = key.data.string;
+  } else {
+    api_free_object(key);
+    dict->data.dictionary.items[dict->data.dictionary.size].key
+        = STATIC_CSTR_TO_STRING("__INVALID_KEY__");
+  }
+}
+
+#define TYPVAL_ENCODE_CONV_DICT_AFTER_KEY() \
+    typval_encode_after_key(edata)
+
+static inline void typval_encode_between_dict_items(EncodedData *const edata)
+  FUNC_ATTR_ALWAYS_INLINE FUNC_ATTR_NONNULL_ALL
+{
+  Object val = kv_pop(edata->stack);
+  Object *const dict = &kv_last(edata->stack);
+  assert(dict->type == kObjectTypeDictionary);
+  assert(dict->data.dictionary.size < dict->data.dictionary.capacity);
+  dict->data.dictionary.items[dict->data.dictionary.size++].value = val;
+}
+
+#define TYPVAL_ENCODE_CONV_DICT_BETWEEN_ITEMS() \
+    typval_encode_between_dict_items(edata)
+
+static inline void typval_encode_dict_end(EncodedData *const edata)
+  FUNC_ATTR_ALWAYS_INLINE FUNC_ATTR_NONNULL_ALL
+{
+  typval_encode_between_dict_items(edata);
+#ifndef NDEBUG
+  const Object *const dict = &kv_last(edata->stack);
+  assert(dict->data.dictionary.size == dict->data.dictionary.capacity);
+#endif
+}
+
+#define TYPVAL_ENCODE_CONV_DICT_END() \
+    typval_encode_dict_end(edata)
+
+#define TYPVAL_ENCODE_CONV_RECURSE(val, conv_type) \
+    TYPVAL_ENCODE_CONV_NIL()
+
+TYPVAL_ENCODE_DEFINE_CONV_FUNCTIONS(static, object, EncodedData *const, edata)
+
+#undef TYPVAL_ENCODE_CONV_STRING
+#undef TYPVAL_ENCODE_CONV_STR_STRING
+#undef TYPVAL_ENCODE_CONV_EXT_STRING
+#undef TYPVAL_ENCODE_CONV_NUMBER
+#undef TYPVAL_ENCODE_CONV_FLOAT
+#undef TYPVAL_ENCODE_CONV_FUNC
+#undef TYPVAL_ENCODE_CONV_EMPTY_LIST
+#undef TYPVAL_ENCODE_CONV_LIST_START
+#undef TYPVAL_ENCODE_CONV_EMPTY_DICT
+#undef TYPVAL_ENCODE_CONV_NIL
+#undef TYPVAL_ENCODE_CONV_BOOL
+#undef TYPVAL_ENCODE_CONV_UNSIGNED_NUMBER
+#undef TYPVAL_ENCODE_CONV_DICT_START
+#undef TYPVAL_ENCODE_CONV_DICT_END
+#undef TYPVAL_ENCODE_CONV_DICT_AFTER_KEY
+#undef TYPVAL_ENCODE_CONV_DICT_BETWEEN_ITEMS
+#undef TYPVAL_ENCODE_CONV_SPECIAL_DICT_KEY_CHECK
+#undef TYPVAL_ENCODE_CONV_LIST_END
+#undef TYPVAL_ENCODE_CONV_LIST_BETWEEN_ITEMS
+#undef TYPVAL_ENCODE_CONV_RECURSE
+#undef TYPVAL_ENCODE_ALLOW_SPECIALS
+
 /// Convert a vim object to an `Object` instance, recursively expanding
 /// Arrays/Dictionaries.
 ///
@@ -317,13 +497,12 @@ void set_option_to(void *to, int type, String name, Object value, Error *err)
 /// @return The converted value
 Object vim_to_object(typval_T *obj)
 {
-  Object rv;
-  // We use a lookup table to break out of cyclic references
-  PMap(ptr_t) *lookup = pmap_new(ptr_t)();
-  rv = vim_to_object_rec(obj, lookup);
-  // Free the table
-  pmap_free(ptr_t)(lookup);
-  return rv;
+  EncodedData edata = { .stack = KV_INITIAL_VALUE };
+  encode_vim_to_object(&edata, obj, "vim_to_object argument");
+  Object ret = kv_A(edata.stack, 0);
+  assert(kv_size(edata.stack) == 1);
+  kv_destroy(edata.stack);
+  return ret;
 }
 
 buf_T *find_buffer_by_handle(Buffer buffer, Error *err)
@@ -633,131 +812,6 @@ Object copy_object(Object obj)
   }
 }
 
-/// Recursion helper for the `vim_to_object`. This uses a pointer table
-/// to avoid infinite recursion due to cyclic references
-///
-/// @param obj The source object
-/// @param lookup Lookup table containing pointers to all processed objects
-/// @return The converted value
-static Object vim_to_object_rec(typval_T *obj, PMap(ptr_t) *lookup)
-{
-  Object rv = OBJECT_INIT;
-
-  if (obj->v_type == VAR_LIST || obj->v_type == VAR_DICT) {
-    // Container object, add it to the lookup table
-    if (pmap_has(ptr_t)(lookup, obj)) {
-      // It's already present, meaning we alredy processed it so just return
-      // nil instead.
-      return rv;
-    }
-    pmap_put(ptr_t)(lookup, obj, NULL);
-  }
-
-  switch (obj->v_type) {
-    case VAR_SPECIAL:
-      switch (obj->vval.v_special) {
-        case kSpecialVarTrue:
-        case kSpecialVarFalse: {
-          rv.type = kObjectTypeBoolean;
-          rv.data.boolean = (obj->vval.v_special == kSpecialVarTrue);
-          break;
-        }
-        case kSpecialVarNull: {
-          rv.type = kObjectTypeNil;
-          break;
-        }
-      }
-      break;
-
-    case VAR_STRING:
-      rv.type = kObjectTypeString;
-      rv.data.string = cstr_to_string((char *) obj->vval.v_string);
-      break;
-
-    case VAR_NUMBER:
-      rv.type = kObjectTypeInteger;
-      rv.data.integer = obj->vval.v_number;
-      break;
-
-    case VAR_FLOAT:
-      rv.type = kObjectTypeFloat;
-      rv.data.floating = obj->vval.v_float;
-      break;
-
-    case VAR_LIST:
-      {
-        list_T *list = obj->vval.v_list;
-        listitem_T *item;
-
-        if (list != NULL) {
-          rv.type = kObjectTypeArray;
-          assert(list->lv_len >= 0);
-          rv.data.array.size = (size_t)list->lv_len;
-          rv.data.array.items = xmalloc(rv.data.array.size * sizeof(Object));
-
-          uint32_t i = 0;
-          for (item = list->lv_first; item != NULL; item = item->li_next) {
-            rv.data.array.items[i] = vim_to_object_rec(&item->li_tv, lookup);
-            i++;
-          }
-        }
-      }
-      break;
-
-    case VAR_DICT:
-      {
-        dict_T *dict = obj->vval.v_dict;
-        hashtab_T *ht;
-        uint64_t todo;
-        hashitem_T *hi;
-        dictitem_T *di;
-
-        if (dict != NULL) {
-          ht = &obj->vval.v_dict->dv_hashtab;
-          todo = ht->ht_used;
-          rv.type = kObjectTypeDictionary;
-
-          // Count items
-          rv.data.dictionary.size = 0;
-          for (hi = ht->ht_array; todo > 0; ++hi) {
-            if (!HASHITEM_EMPTY(hi)) {
-              todo--;
-              rv.data.dictionary.size++;
-            }
-          }
-
-          rv.data.dictionary.items =
-            xmalloc(rv.data.dictionary.size * sizeof(KeyValuePair));
-          todo = ht->ht_used;
-          uint32_t i = 0;
-
-          // Convert all
-          for (hi = ht->ht_array; todo > 0; ++hi) {
-            if (!HASHITEM_EMPTY(hi)) {
-              di = dict_lookup(hi);
-              // Convert key
-              rv.data.dictionary.items[i].key =
-                cstr_to_string((char *) hi->hi_key);
-              // Convert value
-              rv.data.dictionary.items[i].value =
-                vim_to_object_rec(&di->di_tv, lookup);
-              todo--;
-              i++;
-            }
-          }
-        }
-      }
-      break;
-
-    case VAR_UNKNOWN:
-    case VAR_FUNC:
-      break;
-  }
-
-  return rv;
-}
-
-
 static void set_option_value_for(char *key,
                                  int numval,
                                  char *stringval,
diff --git a/src/nvim/api/private/helpers.h b/src/nvim/api/private/helpers.h
index a0f14ac7a4..a946e35149 100644
--- a/src/nvim/api/private/helpers.h
+++ b/src/nvim/api/private/helpers.h
@@ -8,69 +8,70 @@
 #include "nvim/memory.h"
 #include "nvim/lib/kvec.h"
 
-#define api_set_error(err, errtype, ...)             \
-  do {                                               \
-    snprintf((err)->msg,                             \
-             sizeof((err)->msg),                     \
-             __VA_ARGS__);                           \
-    (err)->set = true;                               \
-    (err)->type = kErrorType##errtype;               \
+#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) {                                            \
-  .type = kObjectTypeBoolean,                                                 \
-  .data.boolean = b                                                           \
-  })
-
-#define INTEGER_OBJ(i) ((Object) {                                            \
-  .type = kObjectTypeInteger,                                                 \
-  .data.integer = i                                                           \
-  })
-
-#define STRING_OBJ(s) ((Object) {                                             \
-  .type = kObjectTypeString,                                                  \
-  .data.string = s                                                            \
-  })
-
-#define BUFFER_OBJ(s) ((Object) {                                             \
-  .type = kObjectTypeBuffer,                                                  \
-  .data.buffer = s                                                            \
-  })
-
-#define WINDOW_OBJ(s) ((Object) {                                             \
-  .type = kObjectTypeWindow,                                                  \
-  .data.window = s                                                            \
-  })
-
-#define TABPAGE_OBJ(s) ((Object) {                                            \
-  .type = kObjectTypeTabpage,                                                 \
-  .data.tabpage = s                                                           \
-  })
-
-#define ARRAY_OBJ(a) ((Object) {                                              \
-  .type = kObjectTypeArray,                                                   \
-  .data.array = a                                                             \
-  })
-
-#define DICTIONARY_OBJ(d) ((Object) {                                         \
-  .type = kObjectTypeDictionary,                                              \
-  .data.dictionary = d                                                        \
-  })
+#define BOOLEAN_OBJ(b) ((Object) { \
+    .type = kObjectTypeBoolean, \
+    .data.boolean = b })
+
+#define INTEGER_OBJ(i) ((Object) { \
+    .type = kObjectTypeInteger, \
+    .data.integer = i })
+
+#define FLOATING_OBJ(f) ((Object) { \
+    .type = kObjectTypeFloat, \
+    .data.floating = f })
+
+#define STRING_OBJ(s) ((Object) { \
+    .type = kObjectTypeString, \
+    .data.string = s })
+
+#define BUFFER_OBJ(s) ((Object) { \
+    .type = kObjectTypeBuffer, \
+    .data.buffer = s })
+
+#define WINDOW_OBJ(s) ((Object) { \
+    .type = kObjectTypeWindow, \
+    .data.window = s })
+
+#define TABPAGE_OBJ(s) ((Object) { \
+    .type = kObjectTypeTabpage, \
+    .data.tabpage = s })
+
+#define ARRAY_OBJ(a) ((Object) { \
+    .type = kObjectTypeArray, \
+    .data.array = a })
+
+#define DICTIONARY_OBJ(d) ((Object) { \
+    .type = kObjectTypeDictionary, \
+    .data.dictionary = d })
 
 #define NIL ((Object) {.type = kObjectTypeNil})
 
-#define PUT(dict, k, v)                                                       \
-  kv_push(KeyValuePair,                                                       \
-          dict,                                                               \
-          ((KeyValuePair) {.key = cstr_to_string(k), .value = v}))
+#define PUT(dict, k, v) \
+  kv_push(dict, ((KeyValuePair) { .key = cstr_to_string(k), .value = v }))
 
-#define ADD(array, item)                                                      \
-  kv_push(Object, array, item)
+#define ADD(array, item) \
+  kv_push(array, item)
 
 #define STATIC_CSTR_AS_STRING(s) ((String) {.data = s, .size = sizeof(s) - 1})
 
+/// Create a new String instance, putting data in allocated memory
+///
+/// @param[in]  s  String to work with. Must be a string literal.
+#define STATIC_CSTR_TO_STRING(s) ((String){ \
+    .data = xmemdupz(s, sizeof(s) - 1), \
+    .size = sizeof(s) - 1 })
+
 // Helpers used by the generated msgpack-rpc api wrappers
 #define api_init_boolean
 #define api_init_integer
diff --git a/src/nvim/api/ui.c b/src/nvim/api/ui.c
new file mode 100644
index 0000000000..1703d49296
--- /dev/null
+++ b/src/nvim/api/ui.c
@@ -0,0 +1,343 @@
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+#include "nvim/vim.h"
+#include "nvim/ui.h"
+#include "nvim/memory.h"
+#include "nvim/map.h"
+#include "nvim/msgpack_rpc/channel.h"
+#include "nvim/api/private/defs.h"
+#include "nvim/api/private/helpers.h"
+
+#ifdef INCLUDE_GENERATED_DECLARATIONS
+# include "api/ui.c.generated.h"
+#endif
+
+typedef struct {
+  uint64_t channel_id;
+  Array buffer;
+} UIData;
+
+static PMap(uint64_t) *connected_uis = NULL;
+
+void remote_ui_init(void)
+    FUNC_API_NOEXPORT
+{
+  connected_uis = pmap_new(uint64_t)();
+}
+
+void remote_ui_disconnect(uint64_t channel_id)
+    FUNC_API_NOEXPORT
+{
+  UI *ui = pmap_get(uint64_t)(connected_uis, channel_id);
+  if (!ui) {
+    return;
+  }
+  UIData *data = ui->data;
+  // destroy pending screen updates
+  api_free_array(data->buffer);
+  pmap_del(uint64_t)(connected_uis, channel_id);
+  xfree(ui->data);
+  ui_detach_impl(ui);
+  xfree(ui);
+}
+
+void ui_attach(uint64_t channel_id, Integer width, Integer height,
+               Boolean enable_rgb, Error *err)
+{
+  if (pmap_has(uint64_t)(connected_uis, channel_id)) {
+    api_set_error(err, Exception, _("UI already attached for channel"));
+    return;
+  }
+
+  if (width <= 0 || height <= 0) {
+    api_set_error(err, Validation,
+                  _("Expected width > 0 and height > 0"));
+    return;
+  }
+  UIData *data = xmalloc(sizeof(UIData));
+  data->channel_id = channel_id;
+  data->buffer = (Array)ARRAY_DICT_INIT;
+  UI *ui = xcalloc(1, sizeof(UI));
+  ui->width = (int)width;
+  ui->height = (int)height;
+  ui->rgb = enable_rgb;
+  ui->data = data;
+  ui->resize = remote_ui_resize;
+  ui->clear = remote_ui_clear;
+  ui->eol_clear = remote_ui_eol_clear;
+  ui->cursor_goto = remote_ui_cursor_goto;
+  ui->update_menu = remote_ui_update_menu;
+  ui->busy_start = remote_ui_busy_start;
+  ui->busy_stop = remote_ui_busy_stop;
+  ui->mouse_on = remote_ui_mouse_on;
+  ui->mouse_off = remote_ui_mouse_off;
+  ui->mode_change = remote_ui_mode_change;
+  ui->set_scroll_region = remote_ui_set_scroll_region;
+  ui->scroll = remote_ui_scroll;
+  ui->highlight_set = remote_ui_highlight_set;
+  ui->put = remote_ui_put;
+  ui->bell = remote_ui_bell;
+  ui->visual_bell = remote_ui_visual_bell;
+  ui->update_fg = remote_ui_update_fg;
+  ui->update_bg = remote_ui_update_bg;
+  ui->update_sp = remote_ui_update_sp;
+  ui->flush = remote_ui_flush;
+  ui->suspend = remote_ui_suspend;
+  ui->set_title = remote_ui_set_title;
+  ui->set_icon = remote_ui_set_icon;
+  pmap_put(uint64_t)(connected_uis, channel_id, ui);
+  ui_attach_impl(ui);
+  return;
+}
+
+void ui_detach(uint64_t channel_id, Error *err)
+{
+  if (!pmap_has(uint64_t)(connected_uis, channel_id)) {
+    api_set_error(err, Exception, _("UI is not attached for channel"));
+  }
+  remote_ui_disconnect(channel_id);
+}
+
+Object ui_try_resize(uint64_t channel_id, Integer width,
+                     Integer height, Error *err)
+{
+  if (!pmap_has(uint64_t)(connected_uis, channel_id)) {
+    api_set_error(err, Exception, _("UI is not attached for channel"));
+  }
+
+  if (width <= 0 || height <= 0) {
+    api_set_error(err, Validation,
+                  _("Expected width > 0 and height > 0"));
+    return NIL;
+  }
+
+  UI *ui = pmap_get(uint64_t)(connected_uis, channel_id);
+  ui->width = (int)width;
+  ui->height = (int)height;
+  ui_refresh();
+  return NIL;
+}
+
+static void push_call(UI *ui, char *name, Array args)
+{
+  Array call = ARRAY_DICT_INIT;
+  UIData *data = ui->data;
+
+  // To optimize data transfer(especially for "put"), we bundle adjacent
+  // calls to same method together, so only add a new call entry if the last
+  // method call is different from "name"
+  if (kv_size(data->buffer)) {
+    call = kv_A(data->buffer, kv_size(data->buffer) - 1).data.array;
+  }
+
+  if (!kv_size(call) || strcmp(kv_A(call, 0).data.string.data, name)) {
+    call = (Array)ARRAY_DICT_INIT;
+    ADD(data->buffer, ARRAY_OBJ(call));
+    ADD(call, STRING_OBJ(cstr_to_string(name)));
+  }
+
+  ADD(call, ARRAY_OBJ(args));
+  kv_A(data->buffer, kv_size(data->buffer) - 1).data.array = call;
+}
+
+static void remote_ui_resize(UI *ui, int width, int height)
+{
+  Array args = ARRAY_DICT_INIT;
+  ADD(args, INTEGER_OBJ(width));
+  ADD(args, INTEGER_OBJ(height));
+  push_call(ui, "resize", args);
+}
+
+static void remote_ui_clear(UI *ui)
+{
+  Array args = ARRAY_DICT_INIT;
+  push_call(ui, "clear", args);
+}
+
+static void remote_ui_eol_clear(UI *ui)
+{
+  Array args = ARRAY_DICT_INIT;
+  push_call(ui, "eol_clear", args);
+}
+
+static void remote_ui_cursor_goto(UI *ui, int row, int col)
+{
+  Array args = ARRAY_DICT_INIT;
+  ADD(args, INTEGER_OBJ(row));
+  ADD(args, INTEGER_OBJ(col));
+  push_call(ui, "cursor_goto", args);
+}
+
+static void remote_ui_update_menu(UI *ui)
+{
+  Array args = ARRAY_DICT_INIT;
+  push_call(ui, "update_menu", args);
+}
+
+static void remote_ui_busy_start(UI *ui)
+{
+  Array args = ARRAY_DICT_INIT;
+  push_call(ui, "busy_start", args);
+}
+
+static void remote_ui_busy_stop(UI *ui)
+{
+  Array args = ARRAY_DICT_INIT;
+  push_call(ui, "busy_stop", args);
+}
+
+static void remote_ui_mouse_on(UI *ui)
+{
+  Array args = ARRAY_DICT_INIT;
+  push_call(ui, "mouse_on", args);
+}
+
+static void remote_ui_mouse_off(UI *ui)
+{
+  Array args = ARRAY_DICT_INIT;
+  push_call(ui, "mouse_off", args);
+}
+
+static void remote_ui_mode_change(UI *ui, int mode)
+{
+  Array args = ARRAY_DICT_INIT;
+  if (mode == INSERT) {
+    ADD(args, STRING_OBJ(cstr_to_string("insert")));
+  } else if (mode == REPLACE) {
+    ADD(args, STRING_OBJ(cstr_to_string("replace")));
+  } else {
+    assert(mode == NORMAL);
+    ADD(args, STRING_OBJ(cstr_to_string("normal")));
+  }
+  push_call(ui, "mode_change", args);
+}
+
+static void remote_ui_set_scroll_region(UI *ui, int top, int bot, int left,
+                                        int right)
+{
+  Array args = ARRAY_DICT_INIT;
+  ADD(args, INTEGER_OBJ(top));
+  ADD(args, INTEGER_OBJ(bot));
+  ADD(args, INTEGER_OBJ(left));
+  ADD(args, INTEGER_OBJ(right));
+  push_call(ui, "set_scroll_region", args);
+}
+
+static void remote_ui_scroll(UI *ui, int count)
+{
+  Array args = ARRAY_DICT_INIT;
+  ADD(args, INTEGER_OBJ(count));
+  push_call(ui, "scroll", args);
+}
+
+static void remote_ui_highlight_set(UI *ui, HlAttrs attrs)
+{
+  Array args = ARRAY_DICT_INIT;
+  Dictionary hl = ARRAY_DICT_INIT;
+
+  if (attrs.bold) {
+    PUT(hl, "bold", BOOLEAN_OBJ(true));
+  }
+
+  if (attrs.underline) {
+    PUT(hl, "underline", BOOLEAN_OBJ(true));
+  }
+
+  if (attrs.undercurl) {
+    PUT(hl, "undercurl", BOOLEAN_OBJ(true));
+  }
+
+  if (attrs.italic) {
+    PUT(hl, "italic", BOOLEAN_OBJ(true));
+  }
+
+  if (attrs.reverse) {
+    PUT(hl, "reverse", BOOLEAN_OBJ(true));
+  }
+
+  if (attrs.foreground != -1) {
+    PUT(hl, "foreground", INTEGER_OBJ(attrs.foreground));
+  }
+
+  if (attrs.background != -1) {
+    PUT(hl, "background", INTEGER_OBJ(attrs.background));
+  }
+
+  if (attrs.special != -1) {
+    PUT(hl, "special", INTEGER_OBJ(attrs.special));
+  }
+
+  ADD(args, DICTIONARY_OBJ(hl));
+  push_call(ui, "highlight_set", args);
+}
+
+static void remote_ui_put(UI *ui, uint8_t *data, size_t size)
+{
+  Array args = ARRAY_DICT_INIT;
+  String str = { .data = xmemdupz(data, size), .size = size };
+  ADD(args, STRING_OBJ(str));
+  push_call(ui, "put", args);
+}
+
+static void remote_ui_bell(UI *ui)
+{
+  Array args = ARRAY_DICT_INIT;
+  push_call(ui, "bell", args);
+}
+
+static void remote_ui_visual_bell(UI *ui)
+{
+  Array args = ARRAY_DICT_INIT;
+  push_call(ui, "visual_bell", args);
+}
+
+static void remote_ui_update_fg(UI *ui, int fg)
+{
+  Array args = ARRAY_DICT_INIT;
+  ADD(args, INTEGER_OBJ(fg));
+  push_call(ui, "update_fg", args);
+}
+
+static void remote_ui_update_bg(UI *ui, int bg)
+{
+  Array args = ARRAY_DICT_INIT;
+  ADD(args, INTEGER_OBJ(bg));
+  push_call(ui, "update_bg", args);
+}
+
+static void remote_ui_update_sp(UI *ui, int sp)
+{
+  Array args = ARRAY_DICT_INIT;
+  ADD(args, INTEGER_OBJ(sp));
+  push_call(ui, "update_sp", args);
+}
+
+static void remote_ui_flush(UI *ui)
+{
+  UIData *data = ui->data;
+  channel_send_event(data->channel_id, "redraw", data->buffer);
+  data->buffer = (Array)ARRAY_DICT_INIT;
+}
+
+static void remote_ui_suspend(UI *ui)
+{
+  Array args = ARRAY_DICT_INIT;
+  push_call(ui, "suspend", args);
+}
+
+static void remote_ui_set_title(UI *ui, char *title)
+{
+  Array args = ARRAY_DICT_INIT;
+  ADD(args, STRING_OBJ(cstr_to_string(title)));
+  push_call(ui, "set_title", args);
+}
+
+static void remote_ui_set_icon(UI *ui, char *icon)
+{
+  Array args = ARRAY_DICT_INIT;
+  ADD(args, STRING_OBJ(cstr_to_string(icon)));
+  push_call(ui, "set_icon", args);
+}
diff --git a/src/nvim/api/ui.h b/src/nvim/api/ui.h
new file mode 100644
index 0000000000..b3af14f8a8
--- /dev/null
+++ b/src/nvim/api/ui.h
@@ -0,0 +1,11 @@
+#ifndef NVIM_API_UI_H
+#define NVIM_API_UI_H
+
+#include <stdint.h>
+
+#include "nvim/api/private/defs.h"
+
+#ifdef INCLUDE_GENERATED_DECLARATIONS
+# include "api/ui.h.generated.h"
+#endif
+#endif  // NVIM_API_UI_H
diff --git a/src/nvim/api/vim.c b/src/nvim/api/vim.c
index 46ac3c9022..ac7cc65ee4 100644
--- a/src/nvim/api/vim.c
+++ b/src/nvim/api/vim.c
@@ -57,6 +57,7 @@ void vim_feedkeys(String keys, String mode, Boolean escape_csi)
   bool remap = true;
   bool insert = false;
   bool typed = false;
+  bool execute = false;
 
   if (keys.size == 0) {
     return;
@@ -68,6 +69,7 @@ void vim_feedkeys(String keys, String mode, Boolean escape_csi)
     case 'm': remap = true; break;
     case 't': typed = true; break;
     case 'i': insert = true; break;
+    case 'x': execute = true; break;
     }
   }
 
@@ -86,8 +88,12 @@ void vim_feedkeys(String keys, String mode, Boolean escape_csi)
       xfree(keys_esc);
   }
 
-  if (vgetc_busy)
+  if (vgetc_busy) {
     typebuf_was_filled = true;
+  }
+  if (execute) {
+    exec_normal(true);
+  }
 }
 
 /// Passes input keys to Neovim. Unlike `vim_feedkeys`, this will use a
@@ -98,7 +104,7 @@ void vim_feedkeys(String keys, String mode, Boolean escape_csi)
 /// @return The number of bytes actually written, which can be lower than
 ///         requested if the buffer becomes full.
 Integer vim_input(String keys)
-  FUNC_ATTR_ASYNC
+    FUNC_API_ASYNC
 {
   return (Integer)input_enqueue(keys);
 }
@@ -618,7 +624,7 @@ Dictionary vim_get_color_map(void)
 
 
 Array vim_get_api_info(uint64_t channel_id)
-  FUNC_ATTR_ASYNC
+    FUNC_API_ASYNC
 {
   Array rv = ARRAY_DICT_INIT;
 
@@ -641,14 +647,14 @@ static void write_msg(String message, bool to_err)
   static size_t out_pos = 0, err_pos = 0;
   static char out_line_buf[LINE_BUFFER_SIZE], err_line_buf[LINE_BUFFER_SIZE];
 
-#define PUSH_CHAR(i, pos, line_buf, msg)                                      \
-  if (message.data[i] == NL || pos == LINE_BUFFER_SIZE - 1) {                 \
-    line_buf[pos] = NUL;                                                      \
-    msg((uint8_t *)line_buf);                                                 \
-    pos = 0;                                                                  \
-    continue;                                                                 \
-  }                                                                           \
-                                                                              \
+#define PUSH_CHAR(i, pos, line_buf, msg) \
+  if (message.data[i] == NL || pos == LINE_BUFFER_SIZE - 1) { \
+    line_buf[pos] = NUL; \
+    msg((uint8_t *)line_buf); \
+    pos = 0; \
+    continue; \
+  } \
+  \
   line_buf[pos++] = message.data[i];
 
   ++no_wait_return;