From edcc73e766438facc88db19000f054aa52ab8b13 Mon Sep 17 00:00:00 2001
From: Peter Hodge <peter.hodge84@gmail.com>
Date: Fri, 26 Jan 2018 20:36:11 +0100
Subject: [PATCH 01/26] API: Implement buffer updates

Originally written by @phodge in
https://github.com/neovim/neovim/pull/5269.
---
 src/nvim/CMakeLists.txt |   1 +
 src/nvim/api/buffer.c   |  31 ++++++-
 src/nvim/buffer.c       |   8 ++
 src/nvim/buffer_defs.h  |   6 ++
 src/nvim/diff.c         |   2 +-
 src/nvim/ex_cmds.c      |  40 +++++++--
 src/nvim/fold.c         |  27 +++++-
 src/nvim/liveupdate.c   | 195 ++++++++++++++++++++++++++++++++++++++++
 src/nvim/liveupdate.h   |  13 +++
 src/nvim/misc1.c        |  32 +++++--
 src/nvim/normal.c       |   2 +-
 src/nvim/ops.c          |  30 +++----
 src/nvim/terminal.c     |   3 +-
 src/nvim/undo.c         |  30 ++++---
 14 files changed, 371 insertions(+), 49 deletions(-)
 create mode 100644 src/nvim/liveupdate.c
 create mode 100644 src/nvim/liveupdate.h

diff --git a/src/nvim/CMakeLists.txt b/src/nvim/CMakeLists.txt
index 2d803792c8..a8a52a8093 100644
--- a/src/nvim/CMakeLists.txt
+++ b/src/nvim/CMakeLists.txt
@@ -142,6 +142,7 @@ set(CONV_SOURCES
   message.c
   regexp.c
   screen.c
+  liveupdate.c
   search.c
   spell.c
   spellfile.c
diff --git a/src/nvim/api/buffer.c b/src/nvim/api/buffer.c
index fa4ad27e60..159683db9e 100644
--- a/src/nvim/api/buffer.c
+++ b/src/nvim/api/buffer.c
@@ -25,6 +25,7 @@
 #include "nvim/window.h"
 #include "nvim/undo.h"
 #include "nvim/ex_docmd.h"
+#include "nvim/liveupdate.h"
 
 #ifdef INCLUDE_GENERATED_DECLARATIONS
 # include "api/buffer.c.generated.h"
@@ -75,6 +76,34 @@ String buffer_get_line(Buffer buffer, Integer index, Error *err)
   return rv;
 }
 
+/// Activate live updates from this buffer to the current channel.
+///
+///
+/// @param buffer The buffer handle
+/// @param enabled True turns on live updates, False turns them off.
+/// @param[out] err Details of an error that may have occurred
+/// @return False when live updates couldn't be enabled because the buffer isn't
+///         loaded; otherwise True.
+Boolean nvim_buf_live_updates(uint64_t channel_id,
+                              Buffer buffer,
+                              Boolean enabled,
+                              Error *err)
+  FUNC_API_SINCE(3) FUNC_API_REMOTE_ONLY
+{
+  buf_T *buf = find_buffer_by_handle(buffer, err);
+
+  if (!buf) {
+    return false;
+  }
+
+  if (enabled) {
+    return liveupdate_register(buf, channel_id);
+  }
+
+  liveupdate_unregister(buf, channel_id);
+  return true;
+}
+
 /// Sets a buffer line
 ///
 /// @deprecated use nvim_buf_set_lines instead.
@@ -407,7 +436,7 @@ void nvim_buf_set_lines(uint64_t channel_id,
                 false);
   }
 
-  changed_lines((linenr_T)start, 0, (linenr_T)end, (long)extra);
+  changed_lines((linenr_T)start, 0, (linenr_T)end, (long)extra, true);
 
   if (save_curbuf.br_buf == NULL) {
     fix_cursor((linenr_T)start, (linenr_T)end, (linenr_T)extra);
diff --git a/src/nvim/buffer.c b/src/nvim/buffer.c
index ba63822837..124e479686 100644
--- a/src/nvim/buffer.c
+++ b/src/nvim/buffer.c
@@ -73,6 +73,7 @@
 #include "nvim/os/os.h"
 #include "nvim/os/time.h"
 #include "nvim/os/input.h"
+#include "nvim/liveupdate.h"
 
 typedef enum {
   kBLSUnchanged = 0,
@@ -574,6 +575,9 @@ void close_buffer(win_T *win, buf_T *buf, int action, int abort_if_last)
   /* Change directories when the 'acd' option is set. */
   do_autochdir();
 
+  // disable live updates for the current buffer
+  liveupdate_unregister_all(buf);
+
   /*
    * Remove the buffer from the list.
    */
@@ -784,6 +788,8 @@ free_buffer_stuff (
   map_clear_int(buf, MAP_ALL_MODES, true, true);     // clear local abbrevs
   xfree(buf->b_start_fenc);
   buf->b_start_fenc = NULL;
+
+  liveupdate_unregister_all(buf);
 }
 
 /*
@@ -1735,6 +1741,8 @@ buf_T * buflist_new(char_u *ffname, char_u *sfname, linenr_T lnum, int flags)
   clrallmarks(buf);                     /* clear marks */
   fmarks_check_names(buf);              /* check file marks for this file */
   buf->b_p_bl = (flags & BLN_LISTED) ? TRUE : FALSE;    /* init 'buflisted' */
+  kv_destroy(buf->liveupdate_channels);
+  kv_init(buf->liveupdate_channels);
   if (!(flags & BLN_DUMMY)) {
     // Tricky: these autocommands may change the buffer list.  They could also
     // split the window with re-using the one empty buffer. This may result in
diff --git a/src/nvim/buffer_defs.h b/src/nvim/buffer_defs.h
index 807baf02c1..9f6ac15308 100644
--- a/src/nvim/buffer_defs.h
+++ b/src/nvim/buffer_defs.h
@@ -38,6 +38,8 @@ typedef struct {
 #include "nvim/api/private/defs.h"
 // for Map(K, V)
 #include "nvim/map.h"
+// for kvec
+#include "nvim/lib/kvec.h"
 
 #define MODIFIABLE(buf) (buf->b_p_ma)
 
@@ -771,6 +773,10 @@ struct file_buffer {
   BufhlInfo b_bufhl_info;       // buffer stored highlights
 
   kvec_t(BufhlLine *) b_bufhl_move_space;  // temporary space for highlights
+
+  // array of channelids which have asked to receive live updates for this
+  // buffer.
+  kvec_t(uint64_t) liveupdate_channels;
 };
 
 /*
diff --git a/src/nvim/diff.c b/src/nvim/diff.c
index f9e40ed06f..61e0b76558 100644
--- a/src/nvim/diff.c
+++ b/src/nvim/diff.c
@@ -2344,7 +2344,7 @@ void ex_diffgetput(exarg_T *eap)
           }
         }
       }
-      changed_lines(lnum, 0, lnum + count, (long)added);
+      changed_lines(lnum, 0, lnum + count, (long)added, true);
 
       if (dfree != NULL) {
         // Diff is deleted, update folds in other windows.
diff --git a/src/nvim/ex_cmds.c b/src/nvim/ex_cmds.c
index f575d58f05..d68dbc8676 100644
--- a/src/nvim/ex_cmds.c
+++ b/src/nvim/ex_cmds.c
@@ -35,6 +35,7 @@
 #include "nvim/fold.h"
 #include "nvim/getchar.h"
 #include "nvim/indent.h"
+#include "nvim/liveupdate.h"
 #include "nvim/main.h"
 #include "nvim/mark.h"
 #include "nvim/mbyte.h"
@@ -279,7 +280,7 @@ void ex_align(exarg_T *eap)
       new_indent = 0;
     (void)set_indent(new_indent, 0);                    /* set indent */
   }
-  changed_lines(eap->line1, 0, eap->line2 + 1, 0L);
+  changed_lines(eap->line1, 0, eap->line2 + 1, 0L, true);
   curwin->w_cursor = save_curpos;
   beginline(BL_WHITE | BL_FIX);
 }
@@ -612,7 +613,7 @@ void ex_sort(exarg_T *eap)
   } else if (deleted < 0) {
     mark_adjust(eap->line2, MAXLNUM, -deleted, 0L, false);
   }
-  changed_lines(eap->line1, 0, eap->line2 + 1, -deleted);
+  changed_lines(eap->line1, 0, eap->line2 + 1, -deleted, true);
 
   curwin->w_cursor.lnum = eap->line1;
   beginline(BL_WHITE | BL_FIX);
@@ -745,7 +746,7 @@ void ex_retab(exarg_T *eap)
   if (curbuf->b_p_ts != new_ts)
     redraw_curbuf_later(NOT_VALID);
   if (first_line != 0)
-    changed_lines(first_line, 0, last_line + 1, 0L);
+    changed_lines(first_line, 0, last_line + 1, 0L, true);
 
   curwin->w_p_list = save_list;         /* restore 'list' */
 
@@ -806,6 +807,7 @@ int do_move(linenr_T line1, linenr_T line2, linenr_T dest)
    */
   last_line = curbuf->b_ml.ml_line_count;
   mark_adjust_nofold(line1, line2, last_line - line2, 0L, true);
+  changed_lines(last_line - num_lines + 1, 0, last_line + 1, num_lines, false);
   if (dest >= line2) {
     mark_adjust_nofold(line2 + 1, dest, -num_lines, 0L, false);
     FOR_ALL_TAB_WINDOWS(tab, win) {
@@ -828,6 +830,12 @@ int do_move(linenr_T line1, linenr_T line2, linenr_T dest)
   curbuf->b_op_start.col = curbuf->b_op_end.col = 0;
   mark_adjust_nofold(last_line - num_lines + 1, last_line,
                      -(last_line - dest - extra), 0L, true);
+  changed_lines(last_line - num_lines + 1, 0, last_line + 1, -extra, false);
+
+  // send live update regarding the new lines that were added
+  if (kv_size(curbuf->liveupdate_channels)) {
+    liveupdate_send_changes(curbuf, dest + 1, num_lines, 0, true);
+  }
 
   /*
    * Now we delete the original text -- webb
@@ -858,9 +866,14 @@ int do_move(linenr_T line1, linenr_T line2, linenr_T dest)
     last_line = curbuf->b_ml.ml_line_count;
     if (dest > last_line + 1)
       dest = last_line + 1;
-    changed_lines(line1, 0, dest, 0L);
+    changed_lines(line1, 0, dest, 0L, false);
   } else {
-    changed_lines(dest + 1, 0, line1 + num_lines, 0L);
+    changed_lines(dest + 1, 0, line1 + num_lines, 0L, false);
+  }
+
+  // send LiveUpdate regarding lines that were deleted
+  if (kv_size(curbuf->liveupdate_channels)) {
+    liveupdate_send_changes(curbuf, line1 + extra, 0, num_lines, true);
   }
 
   return OK;
@@ -2428,6 +2441,7 @@ int do_ecmd(
         goto theend;
       }
       u_unchanged(curbuf);
+      liveupdate_unregister_all(curbuf);
       buf_freeall(curbuf, BFA_KEEP_UNDO);
 
       // Tell readfile() not to clear or reload undo info.
@@ -3154,7 +3168,8 @@ static char_u *sub_parse_flags(char_u *cmd, subflags_T *subflags,
 /// The usual escapes are supported as described in the regexp docs.
 ///
 /// @return buffer used for 'inccommand' preview
-static buf_T *do_sub(exarg_T *eap, proftime_T timeout)
+static buf_T *do_sub(exarg_T *eap, proftime_T timeout,
+                     bool send_liveupdate_changedtick)
 {
   long i = 0;
   regmmatch_T regmatch;
@@ -4000,7 +4015,14 @@ skip:
      * the line number before the change (same as adding the number of
      * deleted lines). */
     i = curbuf->b_ml.ml_line_count - old_line_count;
-    changed_lines(first_line, 0, last_line - i, i);
+    changed_lines(first_line, 0, last_line - i, i, false);
+
+    if (kv_size(curbuf->liveupdate_channels)) {
+      int64_t num_added = last_line - first_line;
+      int64_t num_removed = num_added - i;
+      liveupdate_send_changes(curbuf, first_line, num_added, num_removed,
+                              send_liveupdate_changedtick);
+    }
   }
 
   xfree(sub_firstline);   /* may have to free allocated copy of the line */
@@ -6246,7 +6268,7 @@ void ex_substitute(exarg_T *eap)
 {
   bool preview = (State & CMDPREVIEW);
   if (*p_icm == NUL || !preview) {  // 'inccommand' is disabled
-    (void)do_sub(eap, profile_zero());
+    (void)do_sub(eap, profile_zero(), true);
     return;
   }
 
@@ -6270,7 +6292,7 @@ void ex_substitute(exarg_T *eap)
   // Don't show search highlighting during live substitution
   bool save_hls = p_hls;
   p_hls = false;
-  buf_T *preview_buf = do_sub(eap, profile_setlimit(p_rdt));
+  buf_T *preview_buf = do_sub(eap, profile_setlimit(p_rdt), false);
   p_hls = save_hls;
 
   if (save_changedtick != curbuf->b_changedtick) {
diff --git a/src/nvim/fold.c b/src/nvim/fold.c
index ad9cd4d562..5758a298ac 100644
--- a/src/nvim/fold.c
+++ b/src/nvim/fold.c
@@ -20,6 +20,7 @@
 #include "nvim/ex_docmd.h"
 #include "nvim/func_attr.h"
 #include "nvim/indent.h"
+#include "nvim/liveupdate.h"
 #include "nvim/mark.h"
 #include "nvim/memline.h"
 #include "nvim/memory.h"
@@ -742,8 +743,20 @@ deleteFold (
     /* Deleting markers may make cursor column invalid. */
     check_cursor_col();
 
-  if (last_lnum > 0)
-    changed_lines(first_lnum, (colnr_T)0, last_lnum, 0L);
+  if (last_lnum > 0) {
+    changed_lines(first_lnum, (colnr_T)0, last_lnum, 0L, false);
+
+    // send one LiveUpdate at the end
+    if (kv_size(curbuf->liveupdate_channels)) {
+      // last_lnum is the line *after* the last line of the outermost fold
+      // that was modified. Note also that deleting a fold might only require
+      // the modification of the *first* line of the fold, but we send through a
+      // notification that includes every line that was part of the fold
+      int64_t num_changed = last_lnum - first_lnum;
+      liveupdate_send_changes(curbuf, first_lnum, num_changed,
+                              num_changed, true);
+    }
+  }
 }
 
 /* clearFolding() {{{2 */
@@ -1590,7 +1603,15 @@ static void foldCreateMarkers(linenr_T start, linenr_T end)
 
   /* Update both changes here, to avoid all folds after the start are
    * changed when the start marker is inserted and the end isn't. */
-  changed_lines(start, (colnr_T)0, end, 0L);
+  changed_lines(start, (colnr_T)0, end, 0L, false);
+
+  if (kv_size(curbuf->liveupdate_channels)) {
+    // Note: foldAddMarker() may not actually change start and/or end if
+    // u_save() is unable to save the buffer line, but we send the LiveUpdate
+    // anyway since it won't do any harm.
+    int64_t num_changed = 1 + end - start;
+    liveupdate_send_changes(curbuf, start, num_changed, num_changed, true);
+  }
 }
 
 /* foldAddMarker() {{{2 */
diff --git a/src/nvim/liveupdate.c b/src/nvim/liveupdate.c
new file mode 100644
index 0000000000..79318e4255
--- /dev/null
+++ b/src/nvim/liveupdate.c
@@ -0,0 +1,195 @@
+#include "nvim/liveupdate.h"
+#include "nvim/memline.h"
+#include "nvim/api/private/helpers.h"
+#include "nvim/msgpack_rpc/channel.h"
+
+// Register a channel. Return True if the channel was added, or already added.
+// Return False if the channel couldn't be added because the buffer is
+// unloaded.
+bool liveupdate_register(buf_T *buf, uint64_t channel_id)
+{
+  // must fail if the buffer isn't loaded
+  if (buf->b_ml.ml_mfp == NULL) {
+    return false;
+  }
+
+  // count how many channels are currently watching the buffer
+  size_t size = kv_size(buf->liveupdate_channels);
+  if (size) {
+    for (size_t i = 0; i < size; i++) {
+      if (kv_A(buf->liveupdate_channels, i) == channel_id) {
+        // buffer is already registered ... nothing to do
+        return true;
+      }
+    }
+  }
+
+  // append the channelid to the list
+  kv_push(buf->liveupdate_channels, channel_id);
+
+  // send through the full channel contents now
+  Array linedata = ARRAY_DICT_INIT;
+  size_t line_count = buf->b_ml.ml_line_count;
+  linedata.size = line_count;
+  linedata.items = xcalloc(sizeof(Object), line_count);
+  for (size_t i = 0; i < line_count; i++) {
+    linenr_T lnum = 1 + (linenr_T)i;
+
+    const char *bufstr = (char *)ml_get_buf(buf, lnum, false);
+    Object str = STRING_OBJ(cstr_to_string(bufstr));
+
+    // Vim represents NULs as NLs, but this may confuse clients.
+    strchrsub(str.data.string.data, '\n', '\0');
+
+    linedata.items[i] = str;
+  }
+
+  Array args = ARRAY_DICT_INIT;
+  args.size = 4;
+  args.items = xcalloc(sizeof(Object), args.size);
+
+  // the first argument is always the buffer handle
+  args.items[0] = BUFFER_OBJ(buf->handle);
+  args.items[1] = INTEGER_OBJ(buf->b_changedtick);
+  args.items[2] = ARRAY_OBJ(linedata);
+  args.items[3] = BOOLEAN_OBJ(false);
+
+  channel_send_event(channel_id, "LiveUpdateStart", args);
+  return true;
+}
+
+void liveupdate_send_end(buf_T *buf, uint64_t channelid)
+{
+    Array args = ARRAY_DICT_INIT;
+    args.size = 1;
+    args.items = xcalloc(sizeof(Object), args.size);
+    args.items[0] = BUFFER_OBJ(buf->handle);
+    channel_send_event(channelid, "LiveUpdateEnd", args);
+}
+
+void liveupdate_unregister(buf_T *buf, uint64_t channelid)
+{
+  size_t size = kv_size(buf->liveupdate_channels);
+  if (!size) {
+    return;
+  }
+
+  // go through list backwards and remove the channel id each time it appears
+  // (it should never appear more than once)
+  size_t j = 0;
+  size_t found = 0;
+  for (size_t i = 0; i < size; i++) {
+    if (kv_A(buf->liveupdate_channels, i) == channelid) {
+      found++;
+    } else {
+      // copy item backwards into prior slot if needed
+      if (i != j) {
+        kv_A(buf->liveupdate_channels, j) = kv_A(buf->liveupdate_channels, i);
+      }
+      j++;
+    }
+  }
+
+  if (found) {
+    // remove X items from the end of the array
+    buf->liveupdate_channels.size -= found;
+
+    // make a new copy of the active array without the channelid in it
+    liveupdate_send_end(buf, channelid);
+  }
+}
+
+void liveupdate_unregister_all(buf_T *buf)
+{
+  size_t size = kv_size(buf->liveupdate_channels);
+  if (size) {
+    for (size_t i = 0; i < size; i++) {
+      liveupdate_send_end(buf, kv_A(buf->liveupdate_channels, i));
+    }
+    kv_destroy(buf->liveupdate_channels);
+    kv_init(buf->liveupdate_channels);
+  }
+}
+
+void liveupdate_send_changes(buf_T *buf, linenr_T firstline, int64_t num_added,
+                             int64_t num_removed, bool send_tick)
+{
+  // if one the channels doesn't work, put its ID here so we can remove it later
+  uint64_t badchannelid = 0;
+
+  // notify each of the active channels
+  for (size_t i = 0; i < kv_size(buf->liveupdate_channels); i++) {
+    uint64_t channelid = kv_A(buf->liveupdate_channels, i);
+
+    // send through the changes now channel contents now
+    Array args = ARRAY_DICT_INIT;
+    args.size = 5;
+    args.items = xcalloc(sizeof(Object), args.size);
+
+    // the first argument is always the buffer handle
+    args.items[0] = BUFFER_OBJ(buf->handle);
+
+    // next argument is b:changedtick
+    args.items[1] = send_tick ? INTEGER_OBJ(buf->b_changedtick) : NIL;
+
+    // the first line that changed (zero-indexed)
+    args.items[2] = INTEGER_OBJ(firstline - 1);
+
+    // how many lines are being swapped out
+    args.items[3] = INTEGER_OBJ(num_removed);
+
+    // linedata of lines being swapped in
+    Array linedata = ARRAY_DICT_INIT;
+    if (num_added > 0) {
+        linedata.size = num_added;
+        linedata.items = xcalloc(sizeof(Object), num_added);
+        for (int64_t i = 0; i < num_added; i++) {
+          int64_t lnum = firstline + i;
+          const char *bufstr = (char *)ml_get_buf(buf, (linenr_T)lnum, false);
+          Object str = STRING_OBJ(cstr_to_string(bufstr));
+
+          // Vim represents NULs as NLs, but this may confuse clients.
+          strchrsub(str.data.string.data, '\n', '\0');
+
+          linedata.items[i] = str;
+        }
+    }
+    args.items[4] = ARRAY_OBJ(linedata);
+    if (!channel_send_event(channelid, "LiveUpdate", args)) {
+      // We can't unregister the channel while we're iterating over the
+      // liveupdate_channels array, so we remember its ID to unregister it at
+      // the end.
+      badchannelid = channelid;
+    }
+  }
+
+  // We can only ever remove one dead channel at a time. This is OK because the
+  // change notifications are so frequent that many dead channels will be
+  // cleared up quickly.
+  if (badchannelid != 0) {
+    ELOG("Disabling live updates for dead channel %llu", badchannelid);
+    liveupdate_unregister(buf, badchannelid);
+  }
+}
+
+void liveupdate_send_tick(buf_T *buf)
+{
+  // notify each of the active channels
+  for (size_t i = 0; i < kv_size(buf->liveupdate_channels); i++) {
+    uint64_t channelid = kv_A(buf->liveupdate_channels, i);
+
+    // send through the changes now channel contents now
+    Array args = ARRAY_DICT_INIT;
+    args.size = 2;
+    args.items = xcalloc(sizeof(Object), args.size);
+
+    // the first argument is always the buffer handle
+    args.items[0] = BUFFER_OBJ(buf->handle);
+
+    // next argument is b:changedtick
+    args.items[1] = INTEGER_OBJ(buf->b_changedtick);
+
+    // don't try and clean up dead channels here
+    channel_send_event(channelid, "LiveUpdateTick", args);
+  }
+}
diff --git a/src/nvim/liveupdate.h b/src/nvim/liveupdate.h
new file mode 100644
index 0000000000..bbee4b3766
--- /dev/null
+++ b/src/nvim/liveupdate.h
@@ -0,0 +1,13 @@
+#ifndef NVIM_LIVEUPDATE_H
+#define NVIM_LIVEUPDATE_H
+
+#include "nvim/buffer_defs.h"
+
+bool liveupdate_register(buf_T *buf, uint64_t channel_id);
+void liveupdate_unregister(buf_T *buf, uint64_t channel_id);
+void liveupdate_unregister_all(buf_T *buf);
+void liveupdate_send_changes(buf_T *buf, linenr_T firstline, int64_t num_added,
+                             int64_t num_removed, bool send_tick);
+void liveupdate_send_tick(buf_T *buf);
+
+#endif  // NVIM_LIVEUPDATE_H
diff --git a/src/nvim/misc1.c b/src/nvim/misc1.c
index 28455f0ba9..a3b2d5e7a4 100644
--- a/src/nvim/misc1.c
+++ b/src/nvim/misc1.c
@@ -28,6 +28,7 @@
 #include "nvim/getchar.h"
 #include "nvim/indent.h"
 #include "nvim/indent_c.h"
+#include "nvim/liveupdate.h"
 #include "nvim/main.h"
 #include "nvim/mark.h"
 #include "nvim/mbyte.h"
@@ -835,7 +836,7 @@ open_line (
       saved_line = NULL;
       if (did_append) {
         changed_lines(curwin->w_cursor.lnum, curwin->w_cursor.col,
-            curwin->w_cursor.lnum + 1, 1L);
+                      curwin->w_cursor.lnum + 1, 1L, true);
         did_append = FALSE;
 
         /* Move marks after the line break to the new line. */
@@ -853,8 +854,9 @@ open_line (
      */
     curwin->w_cursor.lnum = old_cursor.lnum + 1;
   }
-  if (did_append)
-    changed_lines(curwin->w_cursor.lnum, 0, curwin->w_cursor.lnum, 1L);
+  if (did_append) {
+    changed_lines(curwin->w_cursor.lnum, 0, curwin->w_cursor.lnum, 1L, true);
+  }
 
   curwin->w_cursor.col = newcol;
   curwin->w_cursor.coladd = 0;
@@ -1819,6 +1821,10 @@ void changed_bytes(linenr_T lnum, colnr_T col)
 {
   changedOneline(curbuf, lnum);
   changed_common(lnum, col, lnum + 1, 0L);
+  // notify any channels that are watching
+  if (kv_size(curbuf->liveupdate_channels)) {
+    liveupdate_send_changes(curbuf, lnum, 1, 1, true);
+  }
 
   /* Diff highlighting in other diff windows may need to be updated too. */
   if (curwin->w_p_diff) {
@@ -1859,7 +1865,7 @@ static void changedOneline(buf_T *buf, linenr_T lnum)
  */
 void appended_lines(linenr_T lnum, long count)
 {
-  changed_lines(lnum + 1, 0, lnum + 1, count);
+  changed_lines(lnum + 1, 0, lnum + 1, count, true);
 }
 
 /*
@@ -1872,7 +1878,7 @@ void appended_lines_mark(linenr_T lnum, long count)
   if (lnum + count < curbuf->b_ml.ml_line_count || curwin->w_p_diff) {
     mark_adjust(lnum + 1, (linenr_T)MAXLNUM, count, 0L, false);
   }
-  changed_lines(lnum + 1, 0, lnum + 1, count);
+  changed_lines(lnum + 1, 0, lnum + 1, count, true);
 }
 
 /*
@@ -1882,7 +1888,7 @@ void appended_lines_mark(linenr_T lnum, long count)
  */
 void deleted_lines(linenr_T lnum, long count)
 {
-  changed_lines(lnum, 0, lnum + count, -count);
+  changed_lines(lnum, 0, lnum + count, -count, true);
 }
 
 /*
@@ -1893,7 +1899,7 @@ void deleted_lines(linenr_T lnum, long count)
 void deleted_lines_mark(linenr_T lnum, long count)
 {
   mark_adjust(lnum, (linenr_T)(lnum + count - 1), (long)MAXLNUM, -count, false);
-  changed_lines(lnum, 0, lnum + count, -count);
+  changed_lines(lnum, 0, lnum + count, -count, true);
 }
 
 /*
@@ -1913,7 +1919,11 @@ changed_lines (
     linenr_T lnum,              /* first line with change */
     colnr_T col,                /* column in first line with change */
     linenr_T lnume,             /* line below last changed line */
-    long xtra                  /* number of extra lines (negative when deleting) */
+    long xtra,                  /* number of extra lines (negative when deleting) */
+    bool send_liveupdate  // some callers like undo/redo call changed_lines()
+                          // and then increment b_changedtick *again*. This flag
+                          // allows these callers to send the LiveUpdate events
+                          // after they're done modifying b_changedtick.
 )
 {
   changed_lines_buf(curbuf, lnum, lnume, xtra);
@@ -1937,6 +1947,12 @@ changed_lines (
   }
 
   changed_common(lnum, col, lnume, xtra);
+
+  if (send_liveupdate && kv_size(curbuf->liveupdate_channels)) {
+    int64_t num_added = (int64_t)(lnume + xtra - lnum);
+    int64_t num_removed = lnume - lnum;
+    liveupdate_send_changes(curbuf, lnum, num_added, num_removed, true);
+  }
 }
 
 /// Mark line range in buffer as changed.
diff --git a/src/nvim/normal.c b/src/nvim/normal.c
index a2aaf8f9af..a995535da2 100644
--- a/src/nvim/normal.c
+++ b/src/nvim/normal.c
@@ -6140,7 +6140,7 @@ static void n_swapchar(cmdarg_T *cap)
   curwin->w_set_curswant = true;
   if (did_change) {
     changed_lines(startpos.lnum, startpos.col, curwin->w_cursor.lnum + 1,
-        0L);
+                  0L, true);
     curbuf->b_op_start = startpos;
     curbuf->b_op_end = curwin->w_cursor;
     if (curbuf->b_op_end.col > 0)
diff --git a/src/nvim/ops.c b/src/nvim/ops.c
index d874768dfc..692713af73 100644
--- a/src/nvim/ops.c
+++ b/src/nvim/ops.c
@@ -214,7 +214,7 @@ void op_shift(oparg_T *oap, int curs_top, int amount)
     ++curwin->w_cursor.lnum;
   }
 
-  changed_lines(oap->start.lnum, 0, oap->end.lnum + 1, 0L);
+  changed_lines(oap->start.lnum, 0, oap->end.lnum + 1, 0L, true);
 
   if (oap->motion_type == kMTBlockWise) {
     curwin->w_cursor.lnum = oap->start.lnum;
@@ -570,7 +570,7 @@ static void block_insert(oparg_T *oap, char_u *s, int b_insert, struct block_def
     }
   }   /* for all lnum */
 
-  changed_lines(oap->start.lnum + 1, 0, oap->end.lnum + 1, 0L);
+  changed_lines(oap->start.lnum + 1, 0, oap->end.lnum + 1, 0L, true);
 
   State = oldstate;
 }
@@ -634,8 +634,8 @@ void op_reindent(oparg_T *oap, Indenter how)
    * there is no change still need to remove the Visual highlighting. */
   if (last_changed != 0)
     changed_lines(first_changed, 0,
-        oap->is_VIsual ? start_lnum + oap->line_count :
-        last_changed + 1, 0L);
+                  oap->is_VIsual ? start_lnum + oap->line_count :
+                  last_changed + 1, 0L, true);
   else if (oap->is_VIsual)
     redraw_curbuf_later(INVERTED);
 
@@ -1455,7 +1455,7 @@ int op_delete(oparg_T *oap)
 
     check_cursor_col();
     changed_lines(curwin->w_cursor.lnum, curwin->w_cursor.col,
-                  oap->end.lnum + 1, 0L);
+                  oap->end.lnum + 1, 0L, true);
     oap->line_count = 0;  // no lines deleted
   } else if (oap->motion_type == kMTLineWise) {
     if (oap->op_type == OP_CHANGE) {
@@ -1822,7 +1822,7 @@ int op_replace(oparg_T *oap, int c)
 
   curwin->w_cursor = oap->start;
   check_cursor();
-  changed_lines(oap->start.lnum, oap->start.col, oap->end.lnum + 1, 0L);
+  changed_lines(oap->start.lnum, oap->start.col, oap->end.lnum + 1, 0L, true);
 
   /* Set "'[" and "']" marks. */
   curbuf->b_op_start = oap->start;
@@ -1857,7 +1857,7 @@ void op_tilde(oparg_T *oap)
 
     }
     if (did_change)
-      changed_lines(oap->start.lnum, 0, oap->end.lnum + 1, 0L);
+      changed_lines(oap->start.lnum, 0, oap->end.lnum + 1, 0L, true);
   } else {  // not block mode
     if (oap->motion_type == kMTLineWise) {
       oap->start.col = 0;
@@ -1881,7 +1881,7 @@ void op_tilde(oparg_T *oap)
       }
     if (did_change) {
       changed_lines(oap->start.lnum, oap->start.col, oap->end.lnum + 1,
-          0L);
+                    0L, true);
     }
   }
 
@@ -2264,7 +2264,7 @@ int op_change(oparg_T *oap)
         }
       }
       check_cursor();
-      changed_lines(oap->start.lnum + 1, 0, oap->end.lnum + 1, 0L);
+      changed_lines(oap->start.lnum + 1, 0, oap->end.lnum + 1, 0L, true);
       xfree(ins_text);
     }
   }
@@ -3033,7 +3033,7 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
         curwin->w_cursor.col += bd.startspaces;
     }
 
-    changed_lines(lnum, 0, curwin->w_cursor.lnum, nr_lines);
+    changed_lines(lnum, 0, curwin->w_cursor.lnum, nr_lines, true);
 
     /* Set '[ mark. */
     curbuf->b_op_start = curwin->w_cursor;
@@ -3210,10 +3210,10 @@ error:
       // note changed text for displaying and folding
       if (y_type == kMTCharWise) {
         changed_lines(curwin->w_cursor.lnum, col,
-                      curwin->w_cursor.lnum + 1, nr_lines);
+                      curwin->w_cursor.lnum + 1, nr_lines, true);
       } else {
         changed_lines(curbuf->b_op_start.lnum, 0,
-                      curbuf->b_op_start.lnum, nr_lines);
+                      curbuf->b_op_start.lnum, nr_lines, true);
       }
 
       /* put '] mark at last inserted character */
@@ -3693,7 +3693,7 @@ int do_join(size_t count,
   /* Only report the change in the first line here, del_lines() will report
    * the deleted line. */
   changed_lines(curwin->w_cursor.lnum, currsize,
-      curwin->w_cursor.lnum + 1, 0L);
+                curwin->w_cursor.lnum + 1, 0L, true);
 
   /*
    * Delete following lines. To do this we move the cursor there
@@ -4363,7 +4363,7 @@ void op_addsub(oparg_T *oap, linenr_T Prenum1, bool g_cmd)
     }
     change_cnt = do_addsub(oap->op_type, &pos, 0, amount);
     if (change_cnt) {
-      changed_lines(pos.lnum, 0, pos.lnum + 1, 0L);
+      changed_lines(pos.lnum, 0, pos.lnum + 1, 0L, true);
     }
   } else {
     int one_change;
@@ -4419,7 +4419,7 @@ void op_addsub(oparg_T *oap, linenr_T Prenum1, bool g_cmd)
       }
     }
     if (change_cnt) {
-      changed_lines(oap->start.lnum, 0, oap->end.lnum + 1, 0L);
+      changed_lines(oap->start.lnum, 0, oap->end.lnum + 1, 0L, true);
     }
 
     if (!change_cnt && oap->is_VIsual) {
diff --git a/src/nvim/terminal.c b/src/nvim/terminal.c
index 39cb2b6372..735f5a3829 100644
--- a/src/nvim/terminal.c
+++ b/src/nvim/terminal.c
@@ -1234,7 +1234,8 @@ static void refresh_screen(Terminal *term, buf_T *buf)
 
   int change_start = row_to_linenr(term, term->invalid_start);
   int change_end = change_start + changed;
-  changed_lines(change_start, 0, change_end, added);
+  // Note: don't send LiveUpdate event for a :terminal buffer
+  changed_lines(change_start, 0, change_end, added, false);
   term->invalid_start = INT_MAX;
   term->invalid_end = -1;
 }
diff --git a/src/nvim/undo.c b/src/nvim/undo.c
index e1ae4b4cc0..27d745a254 100644
--- a/src/nvim/undo.c
+++ b/src/nvim/undo.c
@@ -92,6 +92,7 @@
 #include "nvim/eval.h"
 #include "nvim/fileio.h"
 #include "nvim/fold.h"
+#include "nvim/liveupdate.h"
 #include "nvim/mark.h"
 #include "nvim/memline.h"
 #include "nvim/message.h"
@@ -1672,7 +1673,7 @@ void u_undo(int count)
     undo_undoes = TRUE;
   else
     undo_undoes = !undo_undoes;
-  u_doit(count, false);
+  u_doit(count, false, true);
 }
 
 /*
@@ -1685,7 +1686,7 @@ void u_redo(int count)
     undo_undoes = false;
   }
 
-  u_doit(count, false);
+  u_doit(count, false, true);
 }
 
 /// Undo and remove the branch from the undo tree.
@@ -1697,7 +1698,9 @@ bool u_undo_and_forget(int count)
     count = 1;
   }
   undo_undoes = true;
-  u_doit(count, true);
+  // don't send a LiveUpdate for this undo is part of 'inccommand' playing with
+  // buffer contents
+  u_doit(count, true, false);
 
   if (curbuf->b_u_curhead == NULL) {
     // nothing was undone.
@@ -1732,7 +1735,7 @@ bool u_undo_and_forget(int count)
 }
 
 /// Undo or redo, depending on `undo_undoes`, `count` times.
-static void u_doit(int startcount, bool quiet)
+static void u_doit(int startcount, bool quiet, bool send_liveupdate)
 {
   int count = startcount;
 
@@ -1768,7 +1771,7 @@ static void u_doit(int startcount, bool quiet)
         break;
       }
 
-      u_undoredo(true);
+      u_undoredo(true, send_liveupdate);
     } else {
       if (curbuf->b_u_curhead == NULL || get_undolevel() <= 0) {
         beep_flush();           /* nothing to redo */
@@ -1779,7 +1782,7 @@ static void u_doit(int startcount, bool quiet)
         break;
       }
 
-      u_undoredo(FALSE);
+      u_undoredo(false, send_liveupdate);
 
       /* Advance for next redo.  Set "newhead" when at the end of the
        * redoable changes. */
@@ -2026,7 +2029,7 @@ void undo_time(long step, int sec, int file, int absolute)
           || (uhp->uh_seq == target && !above))
         break;
       curbuf->b_u_curhead = uhp;
-      u_undoredo(TRUE);
+      u_undoredo(true, true);
       uhp->uh_walk = nomark;            /* don't go back down here */
     }
 
@@ -2082,7 +2085,7 @@ void undo_time(long step, int sec, int file, int absolute)
         break;
       }
 
-      u_undoredo(FALSE);
+      u_undoredo(false, true);
 
       /* Advance "curhead" to below the header we last used.  If it
       * becomes NULL then we need to set "newhead" to this leaf. */
@@ -2114,7 +2117,7 @@ void undo_time(long step, int sec, int file, int absolute)
  *
  * When "undo" is TRUE we go up in the tree, when FALSE we go down.
  */
-static void u_undoredo(int undo)
+static void u_undoredo(int undo, bool send_liveupdate)
 {
   char_u      **newarray = NULL;
   linenr_T oldsize;
@@ -2242,7 +2245,7 @@ static void u_undoredo(int undo)
       }
     }
 
-    changed_lines(top + 1, 0, bot, newsize - oldsize);
+    changed_lines(top + 1, 0, bot, newsize - oldsize, send_liveupdate);
 
     /* set '[ and '] mark */
     if (top + 1 < curbuf->b_op_start.lnum)
@@ -2277,6 +2280,13 @@ static void u_undoredo(int undo)
     unchanged(curbuf, FALSE);
   }
 
+  // because the calls to changed()/unchanged() above will bump b_changedtick
+  // again, we need to send a LiveUpdate with just the new value of
+  // b:changedtick
+  if (send_liveupdate && kv_size(curbuf->liveupdate_channels)) {
+    liveupdate_send_tick(curbuf);
+  }
+
   /*
    * restore marks from before undo/redo
    */

From db15a3b8f77a24d37e41ca53e0b032a7e35cf13a Mon Sep 17 00:00:00 2001
From: Peter Hodge <peter.hodge84@gmail.com>
Date: Fri, 26 Jan 2018 20:37:38 +0100
Subject: [PATCH 02/26] API: Document buffer updates

Originally written by @phodge in
https://github.com/neovim/neovim/pull/5269.
---
 runtime/doc/msgpack_rpc.txt | 188 ++++++++++++++++++++++++++++++++++++
 1 file changed, 188 insertions(+)

diff --git a/runtime/doc/msgpack_rpc.txt b/runtime/doc/msgpack_rpc.txt
index 01d4e10cea..ab77e08bc7 100644
--- a/runtime/doc/msgpack_rpc.txt
+++ b/runtime/doc/msgpack_rpc.txt
@@ -241,4 +241,192 @@ Even for statically compiled clients it is good practice to avoid hardcoding
 the type codes, because a client may be built against one Nvim version but
 connect to another with different type codes.
 
+==============================================================================
+6. Live Updates				      *live-updates* *rpc-live-updates*
+
+A dedicated API has been created to allow co-processes to be notified in
+real-time when the user changes a buffer in any way. It is difficult and
+error-prone to try and do this with autocommands such as |TextChanged|.
+
+							*live-updates-enabling*
+Setting Up~
+
+If your API client is a standalone co-process, it can use the
+`"nvim_buf_live_updates"`API method to activate Live Update events for a
+specific buffer. For example, in python >
+
+	import sys, neovim
+	nvim = neovim.attach('stdio')
+	bufnr = sys.argv[1]
+	nvim.buffers[bufnr].live_updates(True)
+
+After the `"nvim_buf_live_updates"` method is called, neovim will send a
+series of notifications containing the entire buffer's contents and any
+subsequent changes. The buffer's contents are sent via notifications because
+if you were to use the other API methods to retrieve the buffer contents, the
+buffer could be changed again before you turn on live updates. This can cause
+a delay if your plugin activates live updates for a very large buffer, but it
+is the the most efficient way to maintain a copy of the entire buffer's
+contents inside your plugin.
+
+						      *live-updates-disabling*
+Turning Off~
+
+You can use `"nvim_buf_live_updates"` with an argument of `False` to turn off
+notifications. One final notification will be sent to indicate that live
+updates are no longer active for the specified buffer. Alternatively, you can
+just close the channel.
+
+						    *live-updates-limitations*
+Limitations~
+
+Note that any of the following actions will also turn off live updates because
+the buffer contents are unloaded from memory:
+
+  - Closing all a buffer's windows (unless 'hidden' is enabled).
+  - Using |:edit| to reload the buffer
+  - reloading the buffer after it is changed from outside neovim.
+
+							  *live-updates-events*
+Handling Events~
+
+The co-process will start receiving the notification events which will be
+equivilent to the following |rpcnotify()| calls:
+
+1. rpcnotify({channel}, "LiveUpdateStart",		      *LiveUpdateStart*
+             [{buf}, {changedtick}, {linedata}, {more}])
+
+	Neovim will send at least one of these notifications to provide you
+	with the original buffer contents. If the buffer is very large, neovim
+	will send the contents through in multiple events to avoid loading the
+	entire buffer's contents into memory at once.
+
+	{buf} is an API handle for the buffer.
+
+	{changedtick} is the value of |b:changedtick| for the buffer. If you
+	send an API command back to neovim you can check the value of
+	|b:changedtick| as part of your request to ensure that no other
+	changes have been made. See |live-update-race-conditions| for more
+	information.
+
+	{linedata} is a list of strings containing the buffer's contents. If
+	this list contains 100 strings, then they represent lines 1-100 of the
+	buffer.  Newline characters are not included in the strings, so empty
+	lines will be given as empty strings. If you receive another
+	`"LiveUpdateStart"` notification with another {linedata} list, then
+	these lines represent the next N lines of the buffer. I.e., a second
+	notification with another list of 100 strings will represent lines
+	101-200 of the buffer.
+
+	{linedata} will always have at least 1 item, but the maximum length is
+	determined by neovim and not guaranteed to be any particular size.
+	Also the number of {linedata} items may vary between notifications, so
+	your plugin must be prepared to receive the line data in whatever size
+	lists neovim decides to split it into.
+
+	{more} is a boolean which tells you whether or not to expect more
+	`"LiveUpdateStart"` notifications. When {more} is false, you can
+	be certain that you now have the entire buffer's contents.
+
+2. rpcnotify({channel}, "LiveUpdate",				  *LiveUpdate*
+	     [{buf}, {changedtick}, {firstline}, {numreplaced}, {linedata}])
+
+	Indicates that {numreplaced} lines starting at line {firstline} have
+	been replaced with the new line data contained in the {linedata} list.
+	All buffer changes (even adding single characters) will be transmitted
+	as whole-line changes.
+
+	{buf} is an API handle for the buffer.
+
+	{changedtick} is the value of |b:changedtick| for the buffer. If you
+	send an API command back to neovim you can check the value of
+	|b:changedtick| as part of your request to ensure that no other
+	changes have been made.
+
+	{firstline} is the integer line number of the first line that was
+	replaced. Note that {firstline} is zero-indexed, so if line `1` was
+	replaced then {firstline} will be `0` instead of `1`. {firstline} is
+	guaranteed to always be less than or equal to the number of lines that
+	were in the buffer before the lines were replaced.
+
+	{numreplaced} is a positive integer indicating how many lines were
+	replaced. It will be `0` if new lines were added to the buffer but
+	none were replaced. If {numreplaced} is `0` then the new lines were
+	added
+	before the zero-indexed line number in {firstline}.
+
+	{linedata} is a list of strings containing the contents of the new
+	buffer lines. Newline characters are not included in the strings, so
+	empty lines will be given as empty strings. If {numreplaced} is `1` or
+	more, then {linedata} may be an empty list (indicating that lines were
+	deleted from the buffer). But if {numreplaced} is `0` (indicating that
+	lines were added to the buffer) then {linedata} is guaranteed to
+	contain at least 1 item.
+
+	Note: sometimes {changedtick} will be |v:null|, which means that the
+	buffer text *looks* like it has changed, but actually hasn't. In this
+	case the lines in {linedata} contain the modified text that is shown
+	to the user, but doesn't reflect the actual buffer contents. Currently
+	this behaviour is only used for the 'inccommand' option.
+
+3. rpcnotify({channel}, "LiveUpdateTick",		      *LiveUpdateTick*
+	     [{buf}, {changedtick}])
+
+	Indicates that |b:changedtick| was incremented for the buffer {buf},
+	but no text was changed. This is currently only used by undo/redo.
+
+	{buf} is an API handle for the buffer.
+
+	{changedtick} is the new value of |b:changedtick| for that buffer.
+
+4. rpcnotify({channel}, "LiveUpdateEnd", [{buf}])		*LiveUpdateEnd*
+
+	{buf} is an API handle for the buffer.
+
+	Indicates that live updates for the nominated buffer have been
+	disabled, either by calling the api function `"nvim_buf_live_updates"`
+	with argument `false`, or because the buffer was unloaded (see
+	|live-updates-disabling| and |live-updates-limitations| for more
+	information).
+
+							*live-updates-examples*
+Example Events~
+
+If live updates are activated a new empty buffer, the following
+|LiveUpdateStart| event will be sent: >
+
+	rpcnotify({channel}, "LiveUpdateStart", [{buf}, [""], v:false])
+
+If the user adds 2 new lines to the start of a buffer, the following event
+would be generated: >
+
+	rpcnotify({channel}, "LiveUpdate", [{buf}, 0, 0, ["line1", "line2"]])
+
+If the puts the cursor on a line containing the text `"Hello world"` and adds
+a `!` character to the end using insert mode, the following event would be
+generated: >
+
+	rpcnotify({channel}, "LiveUpdate",
+		  [{buf}, {linenr}, 1, ["Hello world!"]])
+
+If the user moves their cursor to line 3 of a buffer and deletes 20 lines
+using `20dd`, the following event will be generated: >
+
+	rpcnotify({channel}, "LiveUpdate", [{buf}, 2, 20, []])
+
+If the user selects lines 3-5 of a buffer using |linewise-visual| mode and
+then presses `p` to paste in a new block of 6 lines, then the following event
+would be sent to the co-process: >
+
+	rpcnotify({channel}, "LiveUpdate",
+		  [{buf}, 2, 3, ['pasted line 1', 'pasted line 2',
+				 'pasted line 3', 'pasted line 4',
+				 'pasted line 5', 'pasted line 6']])
+
+If the user uses :edit to reload a buffer then the following event would be
+generated: >
+
+	rpcnotify({channel}, "LiveUpdateEnd", [{buf}])
+
+
  vim:tw=78:ts=8:ft=help:norl:

From 79184809bb10b738c05c29a973d09bd65798b168 Mon Sep 17 00:00:00 2001
From: Peter Hodge <peter.hodge84@gmail.com>
Date: Fri, 26 Jan 2018 20:38:05 +0100
Subject: [PATCH 03/26] Tests for buffer updates

Originally written by @phodge in
https://github.com/neovim/neovim/pull/5269.
---
 test/functional/api/liveupdate_spec.lua | 734 ++++++++++++++++++++++++
 1 file changed, 734 insertions(+)
 create mode 100644 test/functional/api/liveupdate_spec.lua

diff --git a/test/functional/api/liveupdate_spec.lua b/test/functional/api/liveupdate_spec.lua
new file mode 100644
index 0000000000..d6f1b2e384
--- /dev/null
+++ b/test/functional/api/liveupdate_spec.lua
@@ -0,0 +1,734 @@
+local helpers = require('test.functional.helpers')(after_each)
+local eq, ok = helpers.eq, helpers.ok
+local buffer, command, eval, nvim, next_message = helpers.buffer,
+  helpers.command, helpers.eval, helpers.nvim, helpers.next_message
+
+local origlines = {"original line 1",
+                   "original line 2",
+                   "original line 3",
+                   "original line 4",
+                   "original line 5",
+                   "original line 6"}
+
+function sendkeys(keys)
+  nvim('input', keys)
+  -- give neovim some time to process msgpack requests before possibly sending
+  -- more key presses - otherwise they all pile up in the queue and get
+  -- processed at once
+  local ntime = os.clock() + 0.01
+  repeat until os.clock() > ntime
+end
+
+function editoriginal(activate, lines)
+  if not lines then
+    lines = origlines
+  end
+  -- load up the file with the correct contents
+  helpers.clear()
+  return open(activate, lines)
+end
+
+function open(activate, lines)
+  local filename = helpers.tmpname()
+  helpers.write_file(filename, table.concat(lines, "\n").."\n", true)
+  command('edit ' .. filename)
+  local b = nvim('get_current_buf')
+  -- what is the value of b:changedtick?
+  local tick = eval('b:changedtick')
+
+  -- turn on live updates, ensure that the LiveUpdateStart messages
+  -- arrive as expectected
+  if activate then
+    ok(buffer('live_updates', b, true))
+    expectn('LiveUpdateStart', {b, tick, lines, false})
+  end
+
+  return b, tick, filename
+end
+
+function reopen(buf, expectedlines)
+  ok(buffer('live_updates', buf, false))
+  expectn('LiveUpdateEnd', {buf})
+  -- for some reason the :edit! increments tick by 2
+  command('edit!')
+  local tick = eval('b:changedtick')
+  ok(buffer('live_updates', buf, true))
+  expectn('LiveUpdateStart', {buf, tick, origlines, false})
+  command('normal! gg')
+  return tick
+end
+
+function expectn(name, args)
+  -- expect the next message to be the specified notification event
+  eq({'notification', name, args}, next_message())
+end
+
+function reopenwithfolds(b)
+  -- discard any changes to the buffer
+  local tick = reopen(b, origlines)
+
+  -- use markers for folds, make all folds open by default
+  command('setlocal foldmethod=marker foldlevel=20')
+
+  -- add a fold
+  command('2,4fold')
+  tick = tick + 1
+  expectn('LiveUpdate', {b, tick, 1, 3, {'original line 2/*{{{*/',
+                                          'original line 3',
+                                          'original line 4/*}}}*/'}})
+  -- make a new fold that wraps lines 1-6
+  command('1,6fold')
+  tick = tick + 1
+  expectn('LiveUpdate', {b, tick, 0, 6, {'original line 1/*{{{*/',
+                                          'original line 2/*{{{*/',
+                                          'original line 3',
+                                          'original line 4/*}}}*/',
+                                          'original line 5',
+                                          'original line 6/*}}}*/'}})
+  return tick
+end
+
+describe('liveupdate', function()
+  it('knows when you add line to a buffer', function()
+    local b, tick = editoriginal(true)
+
+    -- add a new line at the start of the buffer
+    command('normal! GyyggP')
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 0, 0, {'original line 6'}})
+
+    -- add multiple lines at the start of the file
+    command('normal! GkkyGggP')
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 0, 0, {'original line 4',
+                                           'original line 5',
+                                           'original line 6'}})
+
+    -- add one line to the middle of the file, several times
+    command('normal! ggYjjp')
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 3, 0, {'original line 4'}})
+    command('normal! p')
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 4, 0, {'original line 4'}})
+    command('normal! p')
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 5, 0, {'original line 4'}})
+
+    -- add multiple lines to the middle of the file
+    command('normal! gg4Yjjp')
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 3, 0, {'original line 4',
+                                           'original line 5',
+                                           'original line 6',
+                                           'original line 4'}})
+
+    -- add one line to the end of the file
+    command('normal! ggYGp')
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 17, 0, {'original line 4'}})
+
+    -- add one line to the end of the file, several times
+    command('normal! ggYGppp')
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 18, 0, {'original line 4'}})
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 19, 0, {'original line 4'}})
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 20, 0, {'original line 4'}})
+
+    -- add several lines to the end of the file, several times
+    command('normal! gg4YGp')
+    command('normal! Gp')
+    command('normal! Gp')
+    firstfour = {'original line 4',
+                 'original line 5',
+                 'original line 6',
+                 'original line 4'}
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 21, 0, firstfour})
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 25, 0, firstfour})
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 29, 0, firstfour})
+
+    -- create a new empty buffer and wipe out the old one ... this will
+    -- turn off live updates
+    command('enew!')
+    expectn('LiveUpdateEnd', {b})
+
+    -- add a line at the start of an empty file
+    command('enew')
+    local tick = eval('b:changedtick')
+    b2 = nvim('get_current_buf')
+    ok(buffer('live_updates', b2, true))
+    expectn('LiveUpdateStart', {b2, tick, {""}, false})
+    eval('append(0, ["new line 1"])')
+    tick = tick + 1
+    expectn('LiveUpdate', {b2, tick, 0, 0, {'new line 1'}})
+
+    -- turn off live updates manually
+    buffer('live_updates', b2, false)
+    expectn('LiveUpdateEnd', {b2})
+
+    -- add multiple lines to a blank file
+    command('enew!')
+    b3 = nvim('get_current_buf')
+    ok(buffer('live_updates', b3, true))
+    tick = eval('b:changedtick')
+    expectn('LiveUpdateStart', {b3, tick, {""}, false})
+    eval('append(0, ["new line 1", "new line 2", "new line 3"])')
+    tick = tick + 1
+    expectn('LiveUpdate', {b3, tick, 0, 0, {'new line 1',
+                                            'new line 2',
+                                            'new line 3'}})
+
+    -- use the API itself to add a line to the start of the buffer
+    buffer('set_lines', b3, 0, 0, true, {'New First Line'})
+    tick = tick + 1
+    expectn('LiveUpdate', {b3, tick, 0, 0, {"New First Line"}})
+  end)
+
+  it('knows when you remove lines from a buffer', function()
+    local b, tick = editoriginal(true)
+
+    -- remove one line from start of file
+    command('normal! dd')
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 0, 1, {}})
+
+    -- remove multiple lines from the start of the file
+    command('normal! 4dd')
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 0, 4, {}})
+
+    -- remove multiple lines from middle of file
+    tick = reopen(b, origlines)
+    command('normal! jj3dd')
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 2, 3, {}})
+
+    -- remove one line from the end of the file
+    tick = reopen(b, origlines)
+    command('normal! Gdd')
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 5, 1, {}})
+
+    -- remove multiple lines from the end of the file
+    tick = reopen(b, origlines)
+    command('normal! 4G3dd')
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 3, 3, {}})
+
+    -- pretend to remove heaps lines from the end of the file but really
+    -- just remove two
+    tick = reopen(b, origlines)
+    command('normal! Gk5dd')
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 4, 2, {}})
+  end)
+
+  it('knows when you modify lines of text', function()
+    local b, tick = editoriginal(true)
+    local channel = nvim('get_api_info')[1]
+
+    -- some normal text editing
+    command('normal! A555')
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 0, 1, {'original line 1555'}})
+    command('normal! jj8X')
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 2, 1, {'origin3'}})
+
+    -- modify multiple lines at once using visual block mode
+    tick = reopen(b, origlines)
+    command('normal! jjw')
+    sendkeys('\x16jjllx')
+    tick = tick + 1
+    expectn('LiveUpdate',
+            {b, tick, 2, 3, {'original e 3', 'original e 4', 'original e 5'}})
+
+    -- replace part of a line line using :s
+    tick = reopen(b, origlines)
+    command('3s/line 3/foo/')
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 2, 1, {'original foo'}})
+
+    -- replace parts of several lines line using :s
+    tick = reopen(b, origlines)
+    command('%s/line [35]/foo/')
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 2, 3, {'original foo',
+                                           'original line 4',
+                                           'original foo'}})
+
+    -- type text into the first line of a blank file, one character at a time
+    command('enew!')
+    tick = 2
+    expectn('LiveUpdateEnd', {b})
+    bnew = nvim('get_current_buf')
+    ok(buffer('live_updates', bnew, true))
+    expectn('LiveUpdateStart', {bnew, tick, {''}, false})
+    sendkeys('i')
+    sendkeys('h')
+    sendkeys('e')
+    sendkeys('l')
+    sendkeys('l')
+    sendkeys('o\nworld')
+    expectn('LiveUpdate', {bnew, tick + 1, 0, 1, {'h'}})
+    expectn('LiveUpdate', {bnew, tick + 2, 0, 1, {'he'}})
+    expectn('LiveUpdate', {bnew, tick + 3, 0, 1, {'hel'}})
+    expectn('LiveUpdate', {bnew, tick + 4, 0, 1, {'hell'}})
+    expectn('LiveUpdate', {bnew, tick + 5, 0, 1, {'hello'}})
+    expectn('LiveUpdate', {bnew, tick + 6, 0, 1, {'hello', ''}})
+    expectn('LiveUpdate', {bnew, tick + 7, 1, 1, {'world'}})
+  end)
+
+  it('knows when you replace lines', function()
+    local b, tick = editoriginal(true)
+
+    -- blast away parts of some lines with visual mode
+    command('normal! jjwvjjllx')
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 2, 1, {'original '}})
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 3, 1, {}})
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 3, 1, {'e 5'}})
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 2, 1, {'original e 5'}})
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 3, 1, {}})
+
+    -- blast away a few lines using :g
+    tick = reopen(b, origlines)
+    command('global/line [35]/delete')
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 2, 1, {}})
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 3, 1, {}})
+  end)
+
+  it('knows when you filter lines', function()
+    -- Test filtering lines with !sort
+    local b, tick = editoriginal(true, {"A", "C", "E", "B", "D", "F"})
+
+    command('silent 2,5!sort')
+    -- the change comes through as two changes:
+    -- 1) addition of the new lines after the filtered lines
+    -- 2) removal of the original lines
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 5, 0, {"B", "C", "D", "E"}})
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 1, 4, {}})
+  end)
+
+  it('sends a sensible event when you use "o"', function()
+    b, tick = editoriginal(true, {'AAA', 'BBB'})
+    command('set noautoindent nosmartindent')
+
+    -- use 'o' to start a new line from a line with no indent
+    command('normal! o')
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 1, 0, {""}})
+
+    -- undo the change, indent line 1 a bit, and try again
+    command('undo')
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 1, 1, {}})
+    tick = tick + 1
+    expectn('LiveUpdateTick', {b, tick})
+    command('set autoindent')
+    command('normal! >>')
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 0, 1, {"\tAAA"}})
+    command('normal! ommm')
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 1, 0, {"\t"}})
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 1, 1, {"\tmmm"}})
+
+    -- undo the change, and try again with 'O'
+    command('undo')
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 1, 1, {'\t'}})
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 1, 1, {}})
+    tick = tick + 1
+    expectn('LiveUpdateTick', {b, tick})
+    command('normal! ggOmmm')
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 0, 0, {"\t"}})
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 0, 1, {"\tmmm"}})
+  end)
+
+  it('deactivates when your buffer changes outside vim', function()
+    -- Test changing file from outside vim and reloading using :edit
+    local lines = {"Line 1", "Line 2"};
+    local b, tick, filename = editoriginal(true, lines)
+
+    command('normal! x')
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 0, 1, {'ine 1'}})
+    command('undo')
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 0, 1, {'Line 1'}})
+    tick = tick + 1
+    expectn('LiveUpdateTick', {b, tick})
+
+    -- change the file directly
+    local f = io.open(filename, 'a')
+    f:write("another line\n")
+    f:flush()
+    f:close()
+
+    -- reopen the file and watch live updates shut down
+    command('edit')
+    expectn('LiveUpdateEnd', {b})
+  end)
+
+  it('allows a channel to watch multiple buffers at once', function()
+    -- edit 3 buffers, make sure they all have windows visible so that when we
+    -- move between buffers, none of them are unloaded
+    b1, tick1, f1 = editoriginal(true, {'A1', 'A2'})
+    b1nr = eval('bufnr("")')
+    command('split')
+    b2, tick2, f2 = open(true, {'B1', 'B2'})
+    b2nr = eval('bufnr("")')
+    command('split')
+    b3, tick3, f3 = open(true, {'C1', 'C2'})
+    b3nr = eval('bufnr("")')
+
+    -- make a new window for moving between buffers
+    command('split')
+
+    command('b'..b1nr)
+    command('normal! x')
+    tick1 = tick1 + 1
+    expectn('LiveUpdate', {b1, tick1, 0, 1, {'1'}})
+    command('undo')
+    tick1 = tick1 + 1
+    expectn('LiveUpdate', {b1, tick1, 0, 1, {'A1'}})
+    tick1 = tick1 + 1
+    expectn('LiveUpdateTick', {b1, tick1})
+
+    command('b'..b2nr)
+    command('normal! x')
+    tick2 = tick2 + 1
+    expectn('LiveUpdate', {b2, tick2, 0, 1, {'1'}})
+    command('undo')
+    tick2 = tick2 + 1
+    expectn('LiveUpdate', {b2, tick2, 0, 1, {'B1'}})
+    tick2 = tick2 + 1
+    expectn('LiveUpdateTick', {b2, tick2})
+
+    command('b'..b3nr)
+    command('normal! x')
+    tick3 = tick3 + 1
+    expectn('LiveUpdate', {b3, tick3, 0, 1, {'1'}})
+    command('undo')
+    tick3 = tick3 + 1
+    expectn('LiveUpdate', {b3, tick3, 0, 1, {'C1'}})
+    tick3 = tick3 + 1
+    expectn('LiveUpdateTick', {b3, tick3})
+  end)
+
+  it('doesn\'t get confused when you turn watching on/off many times',
+     function()
+    local channel = nvim('get_api_info')[1]
+    local b, tick = editoriginal(false)
+
+    -- turn on live updates many times
+    ok(buffer('live_updates', b, true))
+    ok(buffer('live_updates', b, true))
+    ok(buffer('live_updates', b, true))
+    ok(buffer('live_updates', b, true))
+    ok(buffer('live_updates', b, true))
+    expectn('LiveUpdateStart', {b, tick, origlines, false})
+    eval('rpcnotify('..channel..', "Hello There")')
+    expectn('Hello There', {})
+
+    -- turn live updates off many times
+    ok(buffer('live_updates', b, false))
+    ok(buffer('live_updates', b, false))
+    ok(buffer('live_updates', b, false))
+    ok(buffer('live_updates', b, false))
+    ok(buffer('live_updates', b, false))
+    expectn('LiveUpdateEnd', {b})
+    eval('rpcnotify('..channel..', "Hello Again")')
+    expectn('Hello Again', {})
+  end)
+
+  it('is able to notify several channels at once', function()
+    helpers.clear()
+
+    local addsession = function(where)
+      eval('serverstart("'..where..'")')
+      local session = helpers.connect(where)
+      return session
+    end
+
+    -- create several new sessions, in addition to our main API
+    sessions = {}
+    sessions[1] = addsession(helpers.tmpname()..'.1')
+    sessions[2] = addsession(helpers.tmpname()..'.2')
+    sessions[3] = addsession(helpers.tmpname()..'.3')
+
+    function request(sessionnr, method, ...)
+      local status, rv = sessions[sessionnr]:request(method, ...)
+      if not status then
+        error(rv[2])
+      end
+      return rv
+    end
+
+    function wantn(sessionid, name, args)
+      local session = sessions[sessionid]
+      eq({'notification', name, args}, session:next_message())
+    end
+
+    -- edit a new file, but don't turn on live updates
+    local lines = {'AAA', 'BBB'}
+    local b, tick = open(false, lines)
+
+    -- turn on live updates for sessions 1, 2 and 3
+    ok(request(1, 'nvim_buf_live_updates', b, true))
+    ok(request(2, 'nvim_buf_live_updates', b, true))
+    ok(request(3, 'nvim_buf_live_updates', b, true))
+    wantn(1, 'LiveUpdateStart', {b, tick, lines, false})
+    wantn(2, 'LiveUpdateStart', {b, tick, lines, false})
+    wantn(3, 'LiveUpdateStart', {b, tick, lines, false})
+
+    -- make a change to the buffer
+    command('normal! x')
+    tick = tick + 1
+    wantn(1, 'LiveUpdate', {b, tick, 0, 1, {'AA'}})
+    wantn(2, 'LiveUpdate', {b, tick, 0, 1, {'AA'}})
+    wantn(3, 'LiveUpdate', {b, tick, 0, 1, {'AA'}})
+
+    -- stop watching on channel 1
+    ok(request(1, 'nvim_buf_live_updates', b, false))
+    wantn(1, 'LiveUpdateEnd', {b})
+
+    -- undo the change to buffer 1
+    command('undo')
+    tick = tick + 1
+    wantn(2, 'LiveUpdate', {b, tick, 0, 1, {'AAA'}})
+    wantn(3, 'LiveUpdate', {b, tick, 0, 1, {'AAA'}})
+    tick = tick + 1
+    wantn(2, 'LiveUpdateTick', {b, tick})
+    wantn(3, 'LiveUpdateTick', {b, tick})
+
+    -- make sure there are no other pending LiveUpdate messages going to
+    -- channel 1
+    local channel1 = request(1, 'nvim_get_api_info')[1]
+    eval('rpcnotify('..channel1..', "Hello")')
+    wantn(1, 'Hello', {})
+
+    -- close the buffer and channels 2 and 3 should get a LiveUpdateEnd
+    -- notification
+    command('edit')
+    wantn(2, 'LiveUpdateEnd', {b})
+    wantn(3, 'LiveUpdateEnd', {b})
+
+    -- make sure there are no other pending LiveUpdate messages going to
+    -- channel 1
+    local channel1 = request(1, 'nvim_get_api_info')[1]
+    eval('rpcnotify('..channel1..', "Hello Again")')
+    wantn(1, 'Hello Again', {})
+  end)
+
+  it('works with :diffput and :diffget', function()
+    local b1, tick1 = editoriginal(true, {"AAA", "BBB"})
+    local channel = nvim('get_api_info')[1]
+    command('diffthis')
+    command('rightbelow vsplit')
+    local b2, tick2 = open(true, {"BBB", "CCC"})
+    command('diffthis')
+    -- go back to first buffer, and push the 'AAA' line to the second buffer
+    command('1wincmd w')
+    command('normal! gg')
+    command('diffput')
+    tick2 = tick2 + 1
+    expectn('LiveUpdate', {b2, tick2, 0, 0, {"AAA"}})
+
+    -- use :diffget to grab the other change from buffer 2
+    command('normal! G')
+    command('diffget')
+    tick1 = tick1 + 1
+    expectn('LiveUpdate', {b1, tick1, 2, 0, {"CCC"}})
+
+    eval('rpcnotify('..channel..', "Goodbye")')
+    expectn('Goodbye', {})
+  end)
+
+  it('works with :sort', function()
+    -- test for :sort
+    local b, tick = editoriginal(true, {"B", "D", "C", "A", "E"})
+    command('%sort')
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 0, 5, {"A", "B", "C", "D", "E"}})
+  end)
+
+  it('works with :left', function()
+    local b, tick = editoriginal(true, {" A", "  B", "B", "\tB", "\t\tC"})
+    local channel = nvim('get_api_info')[1]
+    command('2,4left')
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 1, 3, {"B", "B", "B"}})
+  end)
+
+  it('works with :right', function()
+    local b, tick = editoriginal(true, {" A",
+                                        "\t  B",
+                                        "\t  \tBB",
+                                        " \tB",
+                                        "\t\tC"})
+    local channel = nvim('get_api_info')[1]
+    command('set ts=2 et')
+    command('2,4retab')
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 1, 3, {"    B", "      BB", "  B"}})
+  end)
+
+  it('works with :move', function()
+    local b, tick = editoriginal(true, origlines)
+    local channel = nvim('get_api_info')[1]
+    -- move text down towards the end of the file
+    command('2,3move 4')
+    tick = tick + 2
+    expectn('LiveUpdate', {b, tick, 4, 0, {"original line 2",
+                                           "original line 3"}})
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 1, 2, {}})
+
+    -- move text up towards the start of the file
+    tick = reopen(b, origlines)
+    command('4,5move 2')
+    tick = tick + 2
+    expectn('LiveUpdate', {b, tick, 2, 0, {"original line 4",
+                                           "original line 5"}})
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 5, 2, {}})
+  end)
+
+  it('sends sensible events when you manually add/remove folds', function()
+    local b, tick = editoriginal(true)
+    local channel = nvim('get_api_info')[1]
+    tick = reopenwithfolds(b)
+
+    -- delete the inner fold
+    command('normal! zR3Gzd')
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 1, 3, {'original line 2',
+                                           'original line 3',
+                                           'original line 4'}})
+    -- delete the outer fold
+    command('normal! zd')
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 0, 6, origlines})
+
+    -- discard changes and put the folds back
+    tick = reopenwithfolds(b)
+
+    -- remove both folds at once
+    command('normal! ggzczD')
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 0, 6, origlines})
+
+    -- discard changes and put the folds back
+    tick = reopenwithfolds(b)
+
+    -- now delete all folds at once
+    command('normal! zE')
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 0, 6, origlines})
+
+    -- create a fold from line 4 to the end of the file
+    command('normal! 4GA/*{{{*/')
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 3, 1, {'original line 4/*{{{*/'}})
+
+    -- delete the fold which only has one marker
+    command('normal! Gzd')
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 3, 3, {'original line 4',
+                                           'original line 5',
+                                           'original line 6'}})
+  end)
+
+  it('turns off updates when a buffer is closed', function()
+    local b, tick = editoriginal(true, {'AAA'})
+    local channel = nvim('get_api_info')[1]
+
+    -- test live updates are working
+    command('normal! x')
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 0, 1, {'AA'}})
+    command('undo')
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 0, 1, {'AAA'}})
+    tick = tick + 1
+    expectn('LiveUpdateTick', {b, tick})
+
+    -- close our buffer by creating a new one
+    command('enew')
+    expectn('LiveUpdateEnd', {b})
+
+    -- reopen the original buffer, make sure there are no Live Updates sent
+    command('b1')
+    command('normal! x')
+
+    eval('rpcnotify('..channel..', "Hello There")')
+    expectn('Hello There', {})
+  end)
+  
+  -- test what happens when a buffer is hidden
+  it('keeps updates turned on if the buffer is hidden', function()
+    local b, tick = editoriginal(true, {'AAA'})
+    local channel = nvim('get_api_info')[1]
+
+    -- test live updates are working
+    command('normal! x')
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 0, 1, {'AA'}})
+    command('undo')
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 0, 1, {'AAA'}})
+    tick = tick + 1
+    expectn('LiveUpdateTick', {b, tick})
+
+    -- close our buffer by creating a new one
+    command('set hidden')
+    command('enew')
+
+    -- note that no LiveUpdateEnd is sent
+    eval('rpcnotify('..channel..', "Hello There")')
+    expectn('Hello There', {})
+
+    -- reopen the original buffer, make sure Live Updates are still active
+    command('b1')
+    command('normal! x')
+    tick = tick + 1
+    expectn('LiveUpdate', {b, tick, 0, 1, {'AA'}})
+  end)
+
+  it('turns off live updates when a buffer is unloaded, deleted, or wiped',
+     function()
+    -- start with a blank nvim
+    helpers.clear()
+    -- need to make a new window with a buffer because :bunload doesn't let you
+    -- unload the last buffer
+    for i, cmd in ipairs({'bunload', 'bdelete', 'bwipeout'}) do
+      command('new')
+      -- open a brand spanking new file
+      local b, filename = open(true, {'AAA'})
+
+      -- call :bunload or whatever the command is, and then check that we
+      -- receive a LiveUpdateEnd
+      command(cmd)
+      expectn('LiveUpdateEnd', {b})
+    end
+  end)
+end)

From 9e97f14de2e693a204db39331d59778f1b4802a6 Mon Sep 17 00:00:00 2001
From: KillTheMule <KillTheMule@users.noreply.github.com>
Date: Fri, 26 Jan 2018 14:44:38 +0100
Subject: [PATCH 04/26] Update to latest master

---
 src/nvim/liveupdate.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/nvim/liveupdate.c b/src/nvim/liveupdate.c
index 79318e4255..953c5b52b3 100644
--- a/src/nvim/liveupdate.c
+++ b/src/nvim/liveupdate.c
@@ -54,7 +54,7 @@ bool liveupdate_register(buf_T *buf, uint64_t channel_id)
   args.items[2] = ARRAY_OBJ(linedata);
   args.items[3] = BOOLEAN_OBJ(false);
 
-  channel_send_event(channel_id, "LiveUpdateStart", args);
+  rpc_send_event(channel_id, "LiveUpdateStart", args);
   return true;
 }
 
@@ -64,7 +64,7 @@ void liveupdate_send_end(buf_T *buf, uint64_t channelid)
     args.size = 1;
     args.items = xcalloc(sizeof(Object), args.size);
     args.items[0] = BUFFER_OBJ(buf->handle);
-    channel_send_event(channelid, "LiveUpdateEnd", args);
+    rpc_send_event(channelid, "LiveUpdateEnd", args);
 }
 
 void liveupdate_unregister(buf_T *buf, uint64_t channelid)
@@ -155,7 +155,7 @@ void liveupdate_send_changes(buf_T *buf, linenr_T firstline, int64_t num_added,
         }
     }
     args.items[4] = ARRAY_OBJ(linedata);
-    if (!channel_send_event(channelid, "LiveUpdate", args)) {
+    if (!rpc_send_event(channelid, "LiveUpdate", args)) {
       // We can't unregister the channel while we're iterating over the
       // liveupdate_channels array, so we remember its ID to unregister it at
       // the end.
@@ -190,6 +190,6 @@ void liveupdate_send_tick(buf_T *buf)
     args.items[1] = INTEGER_OBJ(buf->b_changedtick);
 
     // don't try and clean up dead channels here
-    channel_send_event(channelid, "LiveUpdateTick", args);
+    rpc_send_event(channelid, "LiveUpdateTick", args);
   }
 }

From bafae1c427cb1eeb52e4caa641ad134c1e062e8e Mon Sep 17 00:00:00 2001
From: KillTheMule <KillTheMule@users.noreply.github.com>
Date: Fri, 26 Jan 2018 15:49:35 +0100
Subject: [PATCH 05/26] Add argument to not send a buffers content when updates
 are enabled

Add a test.
---
 src/nvim/api/buffer.c                   |  3 +-
 src/nvim/liveupdate.c                   | 26 +++++++------
 src/nvim/liveupdate.h                   |  2 +-
 test/functional/api/liveupdate_spec.lua | 50 ++++++++++++++-----------
 4 files changed, 46 insertions(+), 35 deletions(-)

diff --git a/src/nvim/api/buffer.c b/src/nvim/api/buffer.c
index 159683db9e..e594e4975c 100644
--- a/src/nvim/api/buffer.c
+++ b/src/nvim/api/buffer.c
@@ -87,6 +87,7 @@ String buffer_get_line(Buffer buffer, Integer index, Error *err)
 Boolean nvim_buf_live_updates(uint64_t channel_id,
                               Buffer buffer,
                               Boolean enabled,
+                              Boolean send_buffer,
                               Error *err)
   FUNC_API_SINCE(3) FUNC_API_REMOTE_ONLY
 {
@@ -97,7 +98,7 @@ Boolean nvim_buf_live_updates(uint64_t channel_id,
   }
 
   if (enabled) {
-    return liveupdate_register(buf, channel_id);
+    return liveupdate_register(buf, channel_id, send_buffer);
   }
 
   liveupdate_unregister(buf, channel_id);
diff --git a/src/nvim/liveupdate.c b/src/nvim/liveupdate.c
index 953c5b52b3..9679d72569 100644
--- a/src/nvim/liveupdate.c
+++ b/src/nvim/liveupdate.c
@@ -6,7 +6,7 @@
 // Register a channel. Return True if the channel was added, or already added.
 // Return False if the channel couldn't be added because the buffer is
 // unloaded.
-bool liveupdate_register(buf_T *buf, uint64_t channel_id)
+bool liveupdate_register(buf_T *buf, uint64_t channel_id, bool send_buffer)
 {
   // must fail if the buffer isn't loaded
   if (buf->b_ml.ml_mfp == NULL) {
@@ -27,21 +27,23 @@ bool liveupdate_register(buf_T *buf, uint64_t channel_id)
   // append the channelid to the list
   kv_push(buf->liveupdate_channels, channel_id);
 
-  // send through the full channel contents now
   Array linedata = ARRAY_DICT_INIT;
-  size_t line_count = buf->b_ml.ml_line_count;
-  linedata.size = line_count;
-  linedata.items = xcalloc(sizeof(Object), line_count);
-  for (size_t i = 0; i < line_count; i++) {
-    linenr_T lnum = 1 + (linenr_T)i;
+  if (send_buffer) {
+    // collect buffer contents
+    size_t line_count = buf->b_ml.ml_line_count;
+    linedata.size = line_count;
+    linedata.items = xcalloc(sizeof(Object), line_count);
+    for (size_t i = 0; i < line_count; i++) {
+      linenr_T lnum = 1 + (linenr_T)i;
 
-    const char *bufstr = (char *)ml_get_buf(buf, lnum, false);
-    Object str = STRING_OBJ(cstr_to_string(bufstr));
+      const char *bufstr = (char *)ml_get_buf(buf, lnum, false);
+      Object str = STRING_OBJ(cstr_to_string(bufstr));
 
-    // Vim represents NULs as NLs, but this may confuse clients.
-    strchrsub(str.data.string.data, '\n', '\0');
+      // Vim represents NULs as NLs, but this may confuse clients.
+      strchrsub(str.data.string.data, '\n', '\0');
 
-    linedata.items[i] = str;
+      linedata.items[i] = str;
+    }
   }
 
   Array args = ARRAY_DICT_INIT;
diff --git a/src/nvim/liveupdate.h b/src/nvim/liveupdate.h
index bbee4b3766..77fb420bf0 100644
--- a/src/nvim/liveupdate.h
+++ b/src/nvim/liveupdate.h
@@ -3,7 +3,7 @@
 
 #include "nvim/buffer_defs.h"
 
-bool liveupdate_register(buf_T *buf, uint64_t channel_id);
+bool liveupdate_register(buf_T *buf, uint64_t channel_id, bool send_buffer);
 void liveupdate_unregister(buf_T *buf, uint64_t channel_id);
 void liveupdate_unregister_all(buf_T *buf);
 void liveupdate_send_changes(buf_T *buf, linenr_T firstline, int64_t num_added,
diff --git a/test/functional/api/liveupdate_spec.lua b/test/functional/api/liveupdate_spec.lua
index d6f1b2e384..6f83a3e904 100644
--- a/test/functional/api/liveupdate_spec.lua
+++ b/test/functional/api/liveupdate_spec.lua
@@ -39,7 +39,7 @@ function open(activate, lines)
   -- turn on live updates, ensure that the LiveUpdateStart messages
   -- arrive as expectected
   if activate then
-    ok(buffer('live_updates', b, true))
+    ok(buffer('live_updates', b, true, true))
     expectn('LiveUpdateStart', {b, tick, lines, false})
   end
 
@@ -47,12 +47,12 @@ function open(activate, lines)
 end
 
 function reopen(buf, expectedlines)
-  ok(buffer('live_updates', buf, false))
+  ok(buffer('live_updates', buf, false, true))
   expectn('LiveUpdateEnd', {buf})
   -- for some reason the :edit! increments tick by 2
   command('edit!')
   local tick = eval('b:changedtick')
-  ok(buffer('live_updates', buf, true))
+  ok(buffer('live_updates', buf, true, true))
   expectn('LiveUpdateStart', {buf, tick, origlines, false})
   command('normal! gg')
   return tick
@@ -161,20 +161,20 @@ describe('liveupdate', function()
     command('enew')
     local tick = eval('b:changedtick')
     b2 = nvim('get_current_buf')
-    ok(buffer('live_updates', b2, true))
+    ok(buffer('live_updates', b2, true, true))
     expectn('LiveUpdateStart', {b2, tick, {""}, false})
     eval('append(0, ["new line 1"])')
     tick = tick + 1
     expectn('LiveUpdate', {b2, tick, 0, 0, {'new line 1'}})
 
     -- turn off live updates manually
-    buffer('live_updates', b2, false)
+    buffer('live_updates', b2, false, true)
     expectn('LiveUpdateEnd', {b2})
 
     -- add multiple lines to a blank file
     command('enew!')
     b3 = nvim('get_current_buf')
-    ok(buffer('live_updates', b3, true))
+    ok(buffer('live_updates', b3, true, true))
     tick = eval('b:changedtick')
     expectn('LiveUpdateStart', {b3, tick, {""}, false})
     eval('append(0, ["new line 1", "new line 2", "new line 3"])')
@@ -267,7 +267,7 @@ describe('liveupdate', function()
     tick = 2
     expectn('LiveUpdateEnd', {b})
     bnew = nvim('get_current_buf')
-    ok(buffer('live_updates', bnew, true))
+    ok(buffer('live_updates', bnew, true, true))
     expectn('LiveUpdateStart', {bnew, tick, {''}, false})
     sendkeys('i')
     sendkeys('h')
@@ -440,21 +440,21 @@ describe('liveupdate', function()
     local b, tick = editoriginal(false)
 
     -- turn on live updates many times
-    ok(buffer('live_updates', b, true))
-    ok(buffer('live_updates', b, true))
-    ok(buffer('live_updates', b, true))
-    ok(buffer('live_updates', b, true))
-    ok(buffer('live_updates', b, true))
+    ok(buffer('live_updates', b, true, true))
+    ok(buffer('live_updates', b, true, true))
+    ok(buffer('live_updates', b, true, true))
+    ok(buffer('live_updates', b, true, true))
+    ok(buffer('live_updates', b, true, true))
     expectn('LiveUpdateStart', {b, tick, origlines, false})
     eval('rpcnotify('..channel..', "Hello There")')
     expectn('Hello There', {})
 
     -- turn live updates off many times
-    ok(buffer('live_updates', b, false))
-    ok(buffer('live_updates', b, false))
-    ok(buffer('live_updates', b, false))
-    ok(buffer('live_updates', b, false))
-    ok(buffer('live_updates', b, false))
+    ok(buffer('live_updates', b, false, true))
+    ok(buffer('live_updates', b, false, true))
+    ok(buffer('live_updates', b, false, true))
+    ok(buffer('live_updates', b, false, true))
+    ok(buffer('live_updates', b, false, true))
     expectn('LiveUpdateEnd', {b})
     eval('rpcnotify('..channel..', "Hello Again")')
     expectn('Hello Again', {})
@@ -493,9 +493,9 @@ describe('liveupdate', function()
     local b, tick = open(false, lines)
 
     -- turn on live updates for sessions 1, 2 and 3
-    ok(request(1, 'nvim_buf_live_updates', b, true))
-    ok(request(2, 'nvim_buf_live_updates', b, true))
-    ok(request(3, 'nvim_buf_live_updates', b, true))
+    ok(request(1, 'nvim_buf_live_updates', b, true, true))
+    ok(request(2, 'nvim_buf_live_updates', b, true, true))
+    ok(request(3, 'nvim_buf_live_updates', b, true, true))
     wantn(1, 'LiveUpdateStart', {b, tick, lines, false})
     wantn(2, 'LiveUpdateStart', {b, tick, lines, false})
     wantn(3, 'LiveUpdateStart', {b, tick, lines, false})
@@ -508,7 +508,7 @@ describe('liveupdate', function()
     wantn(3, 'LiveUpdate', {b, tick, 0, 1, {'AA'}})
 
     -- stop watching on channel 1
-    ok(request(1, 'nvim_buf_live_updates', b, false))
+    ok(request(1, 'nvim_buf_live_updates', b, false, true))
     wantn(1, 'LiveUpdateEnd', {b})
 
     -- undo the change to buffer 1
@@ -731,4 +731,12 @@ describe('liveupdate', function()
       expectn('LiveUpdateEnd', {b})
     end
   end)
+
+  it('doesn\'t send the buffer\'s content when not requested', function()
+    helpers.clear()
+    local b, tick = editoriginal(false)
+    ok(buffer('live_updates', b, true, false))
+    expectn('LiveUpdateStart', {b, tick, {}, false})
+  end)
+
 end)

From 71816e584cef01c195797e738e1d6dba1de39102 Mon Sep 17 00:00:00 2001
From: KillTheMule <KillTheMule@users.noreply.github.com>
Date: Fri, 26 Jan 2018 16:52:51 +0100
Subject: [PATCH 06/26] Adjust FUNC_API_SINCE for nvim_buf_live_updates

---
 src/nvim/api/buffer.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/nvim/api/buffer.c b/src/nvim/api/buffer.c
index e594e4975c..44e274484a 100644
--- a/src/nvim/api/buffer.c
+++ b/src/nvim/api/buffer.c
@@ -89,7 +89,7 @@ Boolean nvim_buf_live_updates(uint64_t channel_id,
                               Boolean enabled,
                               Boolean send_buffer,
                               Error *err)
-  FUNC_API_SINCE(3) FUNC_API_REMOTE_ONLY
+  FUNC_API_SINCE(4) FUNC_API_REMOTE_ONLY
 {
   buf_T *buf = find_buffer_by_handle(buffer, err);
 

From 8bcc01195968b84d1a74ecb82598bdf538004404 Mon Sep 17 00:00:00 2001
From: KillTheMule <KillTheMule@users.noreply.github.com>
Date: Fri, 26 Jan 2018 17:42:51 +0100
Subject: [PATCH 07/26] Make separate functions to start/stop live updates

---
 runtime/doc/msgpack_rpc.txt             | 26 +++++++--------
 src/nvim/api/buffer.c                   | 28 ++++++++++++----
 test/functional/api/liveupdate_spec.lua | 44 ++++++++++++-------------
 3 files changed, 57 insertions(+), 41 deletions(-)

diff --git a/runtime/doc/msgpack_rpc.txt b/runtime/doc/msgpack_rpc.txt
index ab77e08bc7..6d5ac25b27 100644
--- a/runtime/doc/msgpack_rpc.txt
+++ b/runtime/doc/msgpack_rpc.txt
@@ -258,24 +258,24 @@ specific buffer. For example, in python >
 	import sys, neovim
 	nvim = neovim.attach('stdio')
 	bufnr = sys.argv[1]
-	nvim.buffers[bufnr].live_updates(True)
+	nvim.buffers[bufnr].live_updates_start(True)
 
-After the `"nvim_buf_live_updates"` method is called, neovim will send a
-series of notifications containing the entire buffer's contents and any
-subsequent changes. The buffer's contents are sent via notifications because
-if you were to use the other API methods to retrieve the buffer contents, the
-buffer could be changed again before you turn on live updates. This can cause
-a delay if your plugin activates live updates for a very large buffer, but it
-is the the most efficient way to maintain a copy of the entire buffer's
-contents inside your plugin.
+After the `"nvim_buf_live_updates_start"` method is called with Argument `"True"`,
+neovim will send a series of notifications containing the entire buffer's
+contents and any subsequent changes. The buffer's contents are sent via
+notifications because if you were to use the other API methods to retrieve the
+buffer contents, the buffer could be changed again before you turn on live
+updates. This can cause a delay if your plugin activates live updates for a
+very large buffer, but it is the the most efficient way to maintain a copy of
+the entire buffer's contents inside your plugin.
 
 						      *live-updates-disabling*
 Turning Off~
 
-You can use `"nvim_buf_live_updates"` with an argument of `False` to turn off
-notifications. One final notification will be sent to indicate that live
-updates are no longer active for the specified buffer. Alternatively, you can
-just close the channel.
+You can use `"nvim_buf_live_updates_stop"` to turn off notifications. One
+final notification will be sent to indicate that live updates are no longer
+active for the specified buffer. Alternatively, you can just close the
+channel.
 
 						    *live-updates-limitations*
 Limitations~
diff --git a/src/nvim/api/buffer.c b/src/nvim/api/buffer.c
index 44e274484a..2c7480a16b 100644
--- a/src/nvim/api/buffer.c
+++ b/src/nvim/api/buffer.c
@@ -78,15 +78,14 @@ String buffer_get_line(Buffer buffer, Integer index, Error *err)
 
 /// Activate live updates from this buffer to the current channel.
 ///
-///
 /// @param buffer The buffer handle
-/// @param enabled True turns on live updates, False turns them off.
+/// @param send_buffer Set to true if the initial notification should contain
+///        the whole buffer
 /// @param[out] err Details of an error that may have occurred
 /// @return False when live updates couldn't be enabled because the buffer isn't
 ///         loaded; otherwise True.
-Boolean nvim_buf_live_updates(uint64_t channel_id,
+Boolean nvim_buf_live_updates_start(uint64_t channel_id,
                               Buffer buffer,
-                              Boolean enabled,
                               Boolean send_buffer,
                               Error *err)
   FUNC_API_SINCE(4) FUNC_API_REMOTE_ONLY
@@ -97,8 +96,25 @@ Boolean nvim_buf_live_updates(uint64_t channel_id,
     return false;
   }
 
-  if (enabled) {
-    return liveupdate_register(buf, channel_id, send_buffer);
+  return liveupdate_register(buf, channel_id, send_buffer);
+
+}
+//
+/// Deactivate live updates from this buffer to the current channel.
+///
+/// @param buffer The buffer handle
+/// @param[out] err Details of an error that may have occurred
+/// @return False when live updates couldn't be disabled because the buffer
+///         isn't loaded; otherwise True.
+Boolean nvim_buf_live_updates_stop(uint64_t channel_id,
+                              Buffer buffer,
+                              Error *err)
+  FUNC_API_SINCE(4) FUNC_API_REMOTE_ONLY
+{
+  buf_T *buf = find_buffer_by_handle(buffer, err);
+
+  if (!buf) {
+    return false;
   }
 
   liveupdate_unregister(buf, channel_id);
diff --git a/test/functional/api/liveupdate_spec.lua b/test/functional/api/liveupdate_spec.lua
index 6f83a3e904..9e071ccaa6 100644
--- a/test/functional/api/liveupdate_spec.lua
+++ b/test/functional/api/liveupdate_spec.lua
@@ -39,7 +39,7 @@ function open(activate, lines)
   -- turn on live updates, ensure that the LiveUpdateStart messages
   -- arrive as expectected
   if activate then
-    ok(buffer('live_updates', b, true, true))
+    ok(buffer('live_updates_start', b, true))
     expectn('LiveUpdateStart', {b, tick, lines, false})
   end
 
@@ -47,12 +47,12 @@ function open(activate, lines)
 end
 
 function reopen(buf, expectedlines)
-  ok(buffer('live_updates', buf, false, true))
+  ok(buffer('live_updates_stop', buf))
   expectn('LiveUpdateEnd', {buf})
   -- for some reason the :edit! increments tick by 2
   command('edit!')
   local tick = eval('b:changedtick')
-  ok(buffer('live_updates', buf, true, true))
+  ok(buffer('live_updates_start', buf, true))
   expectn('LiveUpdateStart', {buf, tick, origlines, false})
   command('normal! gg')
   return tick
@@ -161,20 +161,20 @@ describe('liveupdate', function()
     command('enew')
     local tick = eval('b:changedtick')
     b2 = nvim('get_current_buf')
-    ok(buffer('live_updates', b2, true, true))
+    ok(buffer('live_updates_start', b2, true))
     expectn('LiveUpdateStart', {b2, tick, {""}, false})
     eval('append(0, ["new line 1"])')
     tick = tick + 1
     expectn('LiveUpdate', {b2, tick, 0, 0, {'new line 1'}})
 
     -- turn off live updates manually
-    buffer('live_updates', b2, false, true)
+    buffer('live_updates_stop', b2)
     expectn('LiveUpdateEnd', {b2})
 
     -- add multiple lines to a blank file
     command('enew!')
     b3 = nvim('get_current_buf')
-    ok(buffer('live_updates', b3, true, true))
+    ok(buffer('live_updates_start', b3, true))
     tick = eval('b:changedtick')
     expectn('LiveUpdateStart', {b3, tick, {""}, false})
     eval('append(0, ["new line 1", "new line 2", "new line 3"])')
@@ -267,7 +267,7 @@ describe('liveupdate', function()
     tick = 2
     expectn('LiveUpdateEnd', {b})
     bnew = nvim('get_current_buf')
-    ok(buffer('live_updates', bnew, true, true))
+    ok(buffer('live_updates_start', bnew, true))
     expectn('LiveUpdateStart', {bnew, tick, {''}, false})
     sendkeys('i')
     sendkeys('h')
@@ -440,21 +440,21 @@ describe('liveupdate', function()
     local b, tick = editoriginal(false)
 
     -- turn on live updates many times
-    ok(buffer('live_updates', b, true, true))
-    ok(buffer('live_updates', b, true, true))
-    ok(buffer('live_updates', b, true, true))
-    ok(buffer('live_updates', b, true, true))
-    ok(buffer('live_updates', b, true, true))
+    ok(buffer('live_updates_start', b, true))
+    ok(buffer('live_updates_start', b, true))
+    ok(buffer('live_updates_start', b, true))
+    ok(buffer('live_updates_start', b, true))
+    ok(buffer('live_updates_start', b, true))
     expectn('LiveUpdateStart', {b, tick, origlines, false})
     eval('rpcnotify('..channel..', "Hello There")')
     expectn('Hello There', {})
 
     -- turn live updates off many times
-    ok(buffer('live_updates', b, false, true))
-    ok(buffer('live_updates', b, false, true))
-    ok(buffer('live_updates', b, false, true))
-    ok(buffer('live_updates', b, false, true))
-    ok(buffer('live_updates', b, false, true))
+    ok(buffer('live_updates_stop', b))
+    ok(buffer('live_updates_stop', b))
+    ok(buffer('live_updates_stop', b))
+    ok(buffer('live_updates_stop', b))
+    ok(buffer('live_updates_stop', b))
     expectn('LiveUpdateEnd', {b})
     eval('rpcnotify('..channel..', "Hello Again")')
     expectn('Hello Again', {})
@@ -493,9 +493,9 @@ describe('liveupdate', function()
     local b, tick = open(false, lines)
 
     -- turn on live updates for sessions 1, 2 and 3
-    ok(request(1, 'nvim_buf_live_updates', b, true, true))
-    ok(request(2, 'nvim_buf_live_updates', b, true, true))
-    ok(request(3, 'nvim_buf_live_updates', b, true, true))
+    ok(request(1, 'nvim_buf_live_updates_start', b, true))
+    ok(request(2, 'nvim_buf_live_updates_start', b, true))
+    ok(request(3, 'nvim_buf_live_updates_start', b, true))
     wantn(1, 'LiveUpdateStart', {b, tick, lines, false})
     wantn(2, 'LiveUpdateStart', {b, tick, lines, false})
     wantn(3, 'LiveUpdateStart', {b, tick, lines, false})
@@ -508,7 +508,7 @@ describe('liveupdate', function()
     wantn(3, 'LiveUpdate', {b, tick, 0, 1, {'AA'}})
 
     -- stop watching on channel 1
-    ok(request(1, 'nvim_buf_live_updates', b, false, true))
+    ok(request(1, 'nvim_buf_live_updates_stop', b))
     wantn(1, 'LiveUpdateEnd', {b})
 
     -- undo the change to buffer 1
@@ -735,7 +735,7 @@ describe('liveupdate', function()
   it('doesn\'t send the buffer\'s content when not requested', function()
     helpers.clear()
     local b, tick = editoriginal(false)
-    ok(buffer('live_updates', b, true, false))
+    ok(buffer('live_updates_start', b, false))
     expectn('LiveUpdateStart', {b, tick, {}, false})
   end)
 

From 37b8e95fd69ba4991454f79802bfe1bccf7c827a Mon Sep 17 00:00:00 2001
From: KillTheMule <KillTheMule@users.noreply.github.com>
Date: Fri, 26 Jan 2018 20:25:53 +0100
Subject: [PATCH 08/26] Lint

---
 src/nvim/api/buffer.c                   | 11 ++--
 src/nvim/buffer.c                       |  6 +-
 src/nvim/ex_cmds.c                      |  3 +-
 src/nvim/misc1.c                        | 14 ++--
 src/nvim/ops.c                          |  8 ++-
 src/nvim/undo.c                         |  2 +-
 test/functional/api/liveupdate_spec.lua | 85 ++++++++++++-------------
 7 files changed, 63 insertions(+), 66 deletions(-)

diff --git a/src/nvim/api/buffer.c b/src/nvim/api/buffer.c
index 2c7480a16b..6778227a27 100644
--- a/src/nvim/api/buffer.c
+++ b/src/nvim/api/buffer.c
@@ -85,9 +85,9 @@ String buffer_get_line(Buffer buffer, Integer index, Error *err)
 /// @return False when live updates couldn't be enabled because the buffer isn't
 ///         loaded; otherwise True.
 Boolean nvim_buf_live_updates_start(uint64_t channel_id,
-                              Buffer buffer,
-                              Boolean send_buffer,
-                              Error *err)
+                                    Buffer buffer,
+                                    Boolean send_buffer,
+                                    Error *err)
   FUNC_API_SINCE(4) FUNC_API_REMOTE_ONLY
 {
   buf_T *buf = find_buffer_by_handle(buffer, err);
@@ -97,7 +97,6 @@ Boolean nvim_buf_live_updates_start(uint64_t channel_id,
   }
 
   return liveupdate_register(buf, channel_id, send_buffer);
-
 }
 //
 /// Deactivate live updates from this buffer to the current channel.
@@ -107,8 +106,8 @@ Boolean nvim_buf_live_updates_start(uint64_t channel_id,
 /// @return False when live updates couldn't be disabled because the buffer
 ///         isn't loaded; otherwise True.
 Boolean nvim_buf_live_updates_stop(uint64_t channel_id,
-                              Buffer buffer,
-                              Error *err)
+                                   Buffer buffer,
+                                   Error *err)
   FUNC_API_SINCE(4) FUNC_API_REMOTE_ONLY
 {
   buf_T *buf = find_buffer_by_handle(buffer, err);
diff --git a/src/nvim/buffer.c b/src/nvim/buffer.c
index 124e479686..e7ff25ce6b 100644
--- a/src/nvim/buffer.c
+++ b/src/nvim/buffer.c
@@ -1738,9 +1738,9 @@ buf_T * buflist_new(char_u *ffname, char_u *sfname, linenr_T lnum, int flags)
   if (flags & BLN_DUMMY)
     buf->b_flags |= BF_DUMMY;
   buf_clear_file(buf);
-  clrallmarks(buf);                     /* clear marks */
-  fmarks_check_names(buf);              /* check file marks for this file */
-  buf->b_p_bl = (flags & BLN_LISTED) ? TRUE : FALSE;    /* init 'buflisted' */
+  clrallmarks(buf);                     // clear marks
+  fmarks_check_names(buf);              // check file marks for this file
+  buf->b_p_bl = (flags & BLN_LISTED) ? true : false;    // init 'buflisted'
   kv_destroy(buf->liveupdate_channels);
   kv_init(buf->liveupdate_channels);
   if (!(flags & BLN_DUMMY)) {
diff --git a/src/nvim/ex_cmds.c b/src/nvim/ex_cmds.c
index d68dbc8676..e418e0c20e 100644
--- a/src/nvim/ex_cmds.c
+++ b/src/nvim/ex_cmds.c
@@ -745,8 +745,9 @@ void ex_retab(exarg_T *eap)
 
   if (curbuf->b_p_ts != new_ts)
     redraw_curbuf_later(NOT_VALID);
-  if (first_line != 0)
+  if (first_line != 0) {
     changed_lines(first_line, 0, last_line + 1, 0L, true);
+  }
 
   curwin->w_p_list = save_list;         /* restore 'list' */
 
diff --git a/src/nvim/misc1.c b/src/nvim/misc1.c
index a3b2d5e7a4..e2094d7293 100644
--- a/src/nvim/misc1.c
+++ b/src/nvim/misc1.c
@@ -837,7 +837,7 @@ open_line (
       if (did_append) {
         changed_lines(curwin->w_cursor.lnum, curwin->w_cursor.col,
                       curwin->w_cursor.lnum + 1, 1L, true);
-        did_append = FALSE;
+        did_append = false;
 
         /* Move marks after the line break to the new line. */
         if (flags & OPENLINE_MARKFIX)
@@ -1914,12 +1914,12 @@ void deleted_lines_mark(linenr_T lnum, long count)
  * Takes care of calling changed() and updating b_mod_*.
  * Careful: may trigger autocommands that reload the buffer.
  */
-void 
-changed_lines (
-    linenr_T lnum,              /* first line with change */
-    colnr_T col,                /* column in first line with change */
-    linenr_T lnume,             /* line below last changed line */
-    long xtra,                  /* number of extra lines (negative when deleting) */
+void
+changed_lines(
+    linenr_T lnum,        // first line with change
+    colnr_T col,          // column in first line with change
+    linenr_T lnume,       // line below last changed line
+    long xtra,            // number of extra lines (negative when deleting)
     bool send_liveupdate  // some callers like undo/redo call changed_lines()
                           // and then increment b_changedtick *again*. This flag
                           // allows these callers to send the LiveUpdate events
diff --git a/src/nvim/ops.c b/src/nvim/ops.c
index 692713af73..c9e8344ac1 100644
--- a/src/nvim/ops.c
+++ b/src/nvim/ops.c
@@ -632,12 +632,13 @@ void op_reindent(oparg_T *oap, Indenter how)
   /* Mark changed lines so that they will be redrawn.  When Visual
    * highlighting was present, need to continue until the last line.  When
    * there is no change still need to remove the Visual highlighting. */
-  if (last_changed != 0)
+  if (last_changed != 0) {
     changed_lines(first_changed, 0,
                   oap->is_VIsual ? start_lnum + oap->line_count :
                   last_changed + 1, 0L, true);
-  else if (oap->is_VIsual)
+  } else if (oap->is_VIsual) {
     redraw_curbuf_later(INVERTED);
+  }
 
   if (oap->line_count > p_report) {
     i = oap->line_count - (i + 1);
@@ -1856,8 +1857,9 @@ void op_tilde(oparg_T *oap)
       did_change |= one_change;
 
     }
-    if (did_change)
+    if (did_change) {
       changed_lines(oap->start.lnum, 0, oap->end.lnum + 1, 0L, true);
+    }
   } else {  // not block mode
     if (oap->motion_type == kMTLineWise) {
       oap->start.col = 0;
diff --git a/src/nvim/undo.c b/src/nvim/undo.c
index 27d745a254..1c14e93211 100644
--- a/src/nvim/undo.c
+++ b/src/nvim/undo.c
@@ -2030,7 +2030,7 @@ void undo_time(long step, int sec, int file, int absolute)
         break;
       curbuf->b_u_curhead = uhp;
       u_undoredo(true, true);
-      uhp->uh_walk = nomark;            /* don't go back down here */
+      uhp->uh_walk = nomark;            // don't go back down here
     }
 
     /*
diff --git a/test/functional/api/liveupdate_spec.lua b/test/functional/api/liveupdate_spec.lua
index 9e071ccaa6..ba98aa60c8 100644
--- a/test/functional/api/liveupdate_spec.lua
+++ b/test/functional/api/liveupdate_spec.lua
@@ -10,7 +10,12 @@ local origlines = {"original line 1",
                    "original line 5",
                    "original line 6"}
 
-function sendkeys(keys)
+local function expectn(name, args)
+  -- expect the next message to be the specified notification event
+  eq({'notification', name, args}, next_message())
+end
+
+local function sendkeys(keys)
   nvim('input', keys)
   -- give neovim some time to process msgpack requests before possibly sending
   -- more key presses - otherwise they all pile up in the queue and get
@@ -19,16 +24,7 @@ function sendkeys(keys)
   repeat until os.clock() > ntime
 end
 
-function editoriginal(activate, lines)
-  if not lines then
-    lines = origlines
-  end
-  -- load up the file with the correct contents
-  helpers.clear()
-  return open(activate, lines)
-end
-
-function open(activate, lines)
+local function open(activate, lines)
   local filename = helpers.tmpname()
   helpers.write_file(filename, table.concat(lines, "\n").."\n", true)
   command('edit ' .. filename)
@@ -46,24 +42,28 @@ function open(activate, lines)
   return b, tick, filename
 end
 
-function reopen(buf, expectedlines)
+local function editoriginal(activate, lines)
+  if not lines then
+    lines = origlines
+  end
+  -- load up the file with the correct contents
+  helpers.clear()
+  return open(activate, lines)
+end
+
+local function reopen(buf, expectedlines)
   ok(buffer('live_updates_stop', buf))
   expectn('LiveUpdateEnd', {buf})
   -- for some reason the :edit! increments tick by 2
   command('edit!')
   local tick = eval('b:changedtick')
   ok(buffer('live_updates_start', buf, true))
-  expectn('LiveUpdateStart', {buf, tick, origlines, false})
+  expectn('LiveUpdateStart', {buf, tick, expectedlines, false})
   command('normal! gg')
   return tick
 end
 
-function expectn(name, args)
-  -- expect the next message to be the specified notification event
-  eq({'notification', name, args}, next_message())
-end
-
-function reopenwithfolds(b)
+local function reopenwithfolds(b)
   -- discard any changes to the buffer
   local tick = reopen(b, origlines)
 
@@ -141,7 +141,7 @@ describe('liveupdate', function()
     command('normal! gg4YGp')
     command('normal! Gp')
     command('normal! Gp')
-    firstfour = {'original line 4',
+    local firstfour = {'original line 4',
                  'original line 5',
                  'original line 6',
                  'original line 4'}
@@ -159,8 +159,8 @@ describe('liveupdate', function()
 
     -- add a line at the start of an empty file
     command('enew')
-    local tick = eval('b:changedtick')
-    b2 = nvim('get_current_buf')
+    tick = eval('b:changedtick')
+    local b2 = nvim('get_current_buf')
     ok(buffer('live_updates_start', b2, true))
     expectn('LiveUpdateStart', {b2, tick, {""}, false})
     eval('append(0, ["new line 1"])')
@@ -173,7 +173,7 @@ describe('liveupdate', function()
 
     -- add multiple lines to a blank file
     command('enew!')
-    b3 = nvim('get_current_buf')
+    local b3 = nvim('get_current_buf')
     ok(buffer('live_updates_start', b3, true))
     tick = eval('b:changedtick')
     expectn('LiveUpdateStart', {b3, tick, {""}, false})
@@ -230,7 +230,6 @@ describe('liveupdate', function()
 
   it('knows when you modify lines of text', function()
     local b, tick = editoriginal(true)
-    local channel = nvim('get_api_info')[1]
 
     -- some normal text editing
     command('normal! A555')
@@ -266,7 +265,7 @@ describe('liveupdate', function()
     command('enew!')
     tick = 2
     expectn('LiveUpdateEnd', {b})
-    bnew = nvim('get_current_buf')
+    local bnew = nvim('get_current_buf')
     ok(buffer('live_updates_start', bnew, true))
     expectn('LiveUpdateStart', {bnew, tick, {''}, false})
     sendkeys('i')
@@ -324,7 +323,7 @@ describe('liveupdate', function()
   end)
 
   it('sends a sensible event when you use "o"', function()
-    b, tick = editoriginal(true, {'AAA', 'BBB'})
+    local b, tick = editoriginal(true, {'AAA', 'BBB'})
     command('set noautoindent nosmartindent')
 
     -- use 'o' to start a new line from a line with no indent
@@ -391,14 +390,14 @@ describe('liveupdate', function()
   it('allows a channel to watch multiple buffers at once', function()
     -- edit 3 buffers, make sure they all have windows visible so that when we
     -- move between buffers, none of them are unloaded
-    b1, tick1, f1 = editoriginal(true, {'A1', 'A2'})
-    b1nr = eval('bufnr("")')
+    local b1, tick1 = editoriginal(true, {'A1', 'A2'})
+    local b1nr = eval('bufnr("")')
     command('split')
-    b2, tick2, f2 = open(true, {'B1', 'B2'})
-    b2nr = eval('bufnr("")')
+    local b2, tick2 = open(true, {'B1', 'B2'})
+    local b2nr = eval('bufnr("")')
     command('split')
-    b3, tick3, f3 = open(true, {'C1', 'C2'})
-    b3nr = eval('bufnr("")')
+    local b3, tick3 = open(true, {'C1', 'C2'})
+    local b3nr = eval('bufnr("")')
 
     -- make a new window for moving between buffers
     command('split')
@@ -470,12 +469,12 @@ describe('liveupdate', function()
     end
 
     -- create several new sessions, in addition to our main API
-    sessions = {}
+    local sessions = {}
     sessions[1] = addsession(helpers.tmpname()..'.1')
     sessions[2] = addsession(helpers.tmpname()..'.2')
     sessions[3] = addsession(helpers.tmpname()..'.3')
 
-    function request(sessionnr, method, ...)
+    local function request(sessionnr, method, ...)
       local status, rv = sessions[sessionnr]:request(method, ...)
       if not status then
         error(rv[2])
@@ -483,7 +482,7 @@ describe('liveupdate', function()
       return rv
     end
 
-    function wantn(sessionid, name, args)
+    local function wantn(sessionid, name, args)
       local session = sessions[sessionid]
       eq({'notification', name, args}, session:next_message())
     end
@@ -534,7 +533,7 @@ describe('liveupdate', function()
 
     -- make sure there are no other pending LiveUpdate messages going to
     -- channel 1
-    local channel1 = request(1, 'nvim_get_api_info')[1]
+    channel1 = request(1, 'nvim_get_api_info')[1]
     eval('rpcnotify('..channel1..', "Hello Again")')
     wantn(1, 'Hello Again', {})
   end)
@@ -573,7 +572,6 @@ describe('liveupdate', function()
 
   it('works with :left', function()
     local b, tick = editoriginal(true, {" A", "  B", "B", "\tB", "\t\tC"})
-    local channel = nvim('get_api_info')[1]
     command('2,4left')
     tick = tick + 1
     expectn('LiveUpdate', {b, tick, 1, 3, {"B", "B", "B"}})
@@ -585,7 +583,6 @@ describe('liveupdate', function()
                                         "\t  \tBB",
                                         " \tB",
                                         "\t\tC"})
-    local channel = nvim('get_api_info')[1]
     command('set ts=2 et')
     command('2,4retab')
     tick = tick + 1
@@ -594,7 +591,6 @@ describe('liveupdate', function()
 
   it('works with :move', function()
     local b, tick = editoriginal(true, origlines)
-    local channel = nvim('get_api_info')[1]
     -- move text down towards the end of the file
     command('2,3move 4')
     tick = tick + 2
@@ -614,9 +610,8 @@ describe('liveupdate', function()
   end)
 
   it('sends sensible events when you manually add/remove folds', function()
-    local b, tick = editoriginal(true)
-    local channel = nvim('get_api_info')[1]
-    tick = reopenwithfolds(b)
+    local b = editoriginal(true)
+    local tick = reopenwithfolds(b)
 
     -- delete the inner fold
     command('normal! zR3Gzd')
@@ -683,7 +678,7 @@ describe('liveupdate', function()
     eval('rpcnotify('..channel..', "Hello There")')
     expectn('Hello There', {})
   end)
-  
+
   -- test what happens when a buffer is hidden
   it('keeps updates turned on if the buffer is hidden', function()
     local b, tick = editoriginal(true, {'AAA'})
@@ -720,10 +715,10 @@ describe('liveupdate', function()
     helpers.clear()
     -- need to make a new window with a buffer because :bunload doesn't let you
     -- unload the last buffer
-    for i, cmd in ipairs({'bunload', 'bdelete', 'bwipeout'}) do
+    for _, cmd in ipairs({'bunload', 'bdelete', 'bwipeout'}) do
       command('new')
       -- open a brand spanking new file
-      local b, filename = open(true, {'AAA'})
+      local b = open(true, {'AAA'})
 
       -- call :bunload or whatever the command is, and then check that we
       -- receive a LiveUpdateEnd

From 0476e0aef3a82879961acd515b8587fc1b941597 Mon Sep 17 00:00:00 2001
From: KillTheMule <KillTheMule@users.noreply.github.com>
Date: Sat, 27 Jan 2018 14:49:16 +0100
Subject: [PATCH 09/26] Make LiveUpdate return lastline instead of numreplaced

In analogy to `nvim_buf_set_lines`.
---
 runtime/doc/msgpack_rpc.txt             | 20 +++---
 src/nvim/liveupdate.c                   |  4 +-
 test/functional/api/liveupdate_spec.lua | 92 ++++++++++++-------------
 3 files changed, 58 insertions(+), 58 deletions(-)

diff --git a/runtime/doc/msgpack_rpc.txt b/runtime/doc/msgpack_rpc.txt
index 6d5ac25b27..e7c80236f8 100644
--- a/runtime/doc/msgpack_rpc.txt
+++ b/runtime/doc/msgpack_rpc.txt
@@ -329,12 +329,12 @@ equivilent to the following |rpcnotify()| calls:
 	be certain that you now have the entire buffer's contents.
 
 2. rpcnotify({channel}, "LiveUpdate",				  *LiveUpdate*
-	     [{buf}, {changedtick}, {firstline}, {numreplaced}, {linedata}])
+	     [{buf}, {changedtick}, {firstline}, {lastline}, {linedata}])
 
-	Indicates that {numreplaced} lines starting at line {firstline} have
-	been replaced with the new line data contained in the {linedata} list.
-	All buffer changes (even adding single characters) will be transmitted
-	as whole-line changes.
+  Indicates that the lines between {firstline} and {lastline} (end-exclusive,
+  zero-indexed) have been replaced with the new line data contained in the
+  {linedata} list.  All buffer changes (even adding single characters) will be
+  transmitted as whole-line changes.
 
 	{buf} is an API handle for the buffer.
 
@@ -349,11 +349,11 @@ equivilent to the following |rpcnotify()| calls:
 	guaranteed to always be less than or equal to the number of lines that
 	were in the buffer before the lines were replaced.
 
-	{numreplaced} is a positive integer indicating how many lines were
-	replaced. It will be `0` if new lines were added to the buffer but
-	none were replaced. If {numreplaced} is `0` then the new lines were
-	added
-	before the zero-indexed line number in {firstline}.
+  {lastline} is the integer line number of the first line that was not
+  replaced. Note that {lastline} is zero-indexed, so if line numbers 2 to 5
+  were replaced, this will be `5` instead of `6`. {lastline} is guaranteed to
+  always be less than or equal to the number of lines that were in the buffer
+  before the lines were replaced.
 
 	{linedata} is a list of strings containing the contents of the new
 	buffer lines. Newline characters are not included in the strings, so
diff --git a/src/nvim/liveupdate.c b/src/nvim/liveupdate.c
index 9679d72569..6bff75217b 100644
--- a/src/nvim/liveupdate.c
+++ b/src/nvim/liveupdate.c
@@ -137,8 +137,8 @@ void liveupdate_send_changes(buf_T *buf, linenr_T firstline, int64_t num_added,
     // the first line that changed (zero-indexed)
     args.items[2] = INTEGER_OBJ(firstline - 1);
 
-    // how many lines are being swapped out
-    args.items[3] = INTEGER_OBJ(num_removed);
+    // the last line that was changed
+    args.items[3] = INTEGER_OBJ(firstline - 1 + num_removed);
 
     // linedata of lines being swapped in
     Array linedata = ARRAY_DICT_INIT;
diff --git a/test/functional/api/liveupdate_spec.lua b/test/functional/api/liveupdate_spec.lua
index ba98aa60c8..6e5221853d 100644
--- a/test/functional/api/liveupdate_spec.lua
+++ b/test/functional/api/liveupdate_spec.lua
@@ -73,7 +73,7 @@ local function reopenwithfolds(b)
   -- add a fold
   command('2,4fold')
   tick = tick + 1
-  expectn('LiveUpdate', {b, tick, 1, 3, {'original line 2/*{{{*/',
+  expectn('LiveUpdate', {b, tick, 1, 4, {'original line 2/*{{{*/',
                                           'original line 3',
                                           'original line 4/*}}}*/'}})
   -- make a new fold that wraps lines 1-6
@@ -107,18 +107,18 @@ describe('liveupdate', function()
     -- add one line to the middle of the file, several times
     command('normal! ggYjjp')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 3, 0, {'original line 4'}})
+    expectn('LiveUpdate', {b, tick, 3, 3, {'original line 4'}})
     command('normal! p')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 4, 0, {'original line 4'}})
+    expectn('LiveUpdate', {b, tick, 4, 4, {'original line 4'}})
     command('normal! p')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 5, 0, {'original line 4'}})
+    expectn('LiveUpdate', {b, tick, 5, 5, {'original line 4'}})
 
     -- add multiple lines to the middle of the file
     command('normal! gg4Yjjp')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 3, 0, {'original line 4',
+    expectn('LiveUpdate', {b, tick, 3, 3, {'original line 4',
                                            'original line 5',
                                            'original line 6',
                                            'original line 4'}})
@@ -126,16 +126,16 @@ describe('liveupdate', function()
     -- add one line to the end of the file
     command('normal! ggYGp')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 17, 0, {'original line 4'}})
+    expectn('LiveUpdate', {b, tick, 17, 17, {'original line 4'}})
 
     -- add one line to the end of the file, several times
     command('normal! ggYGppp')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 18, 0, {'original line 4'}})
+    expectn('LiveUpdate', {b, tick, 18, 18, {'original line 4'}})
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 19, 0, {'original line 4'}})
+    expectn('LiveUpdate', {b, tick, 19, 19, {'original line 4'}})
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 20, 0, {'original line 4'}})
+    expectn('LiveUpdate', {b, tick, 20, 20, {'original line 4'}})
 
     -- add several lines to the end of the file, several times
     command('normal! gg4YGp')
@@ -146,11 +146,11 @@ describe('liveupdate', function()
                  'original line 6',
                  'original line 4'}
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 21, 0, firstfour})
+    expectn('LiveUpdate', {b, tick, 21, 21, firstfour})
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 25, 0, firstfour})
+    expectn('LiveUpdate', {b, tick, 25, 25, firstfour})
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 29, 0, firstfour})
+    expectn('LiveUpdate', {b, tick, 29, 29, firstfour})
 
     -- create a new empty buffer and wipe out the old one ... this will
     -- turn off live updates
@@ -206,26 +206,26 @@ describe('liveupdate', function()
     tick = reopen(b, origlines)
     command('normal! jj3dd')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 2, 3, {}})
+    expectn('LiveUpdate', {b, tick, 2, 5, {}})
 
     -- remove one line from the end of the file
     tick = reopen(b, origlines)
     command('normal! Gdd')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 5, 1, {}})
+    expectn('LiveUpdate', {b, tick, 5, 6, {}})
 
     -- remove multiple lines from the end of the file
     tick = reopen(b, origlines)
     command('normal! 4G3dd')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 3, 3, {}})
+    expectn('LiveUpdate', {b, tick, 3, 6, {}})
 
     -- pretend to remove heaps lines from the end of the file but really
     -- just remove two
     tick = reopen(b, origlines)
     command('normal! Gk5dd')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 4, 2, {}})
+    expectn('LiveUpdate', {b, tick, 4, 6, {}})
   end)
 
   it('knows when you modify lines of text', function()
@@ -237,7 +237,7 @@ describe('liveupdate', function()
     expectn('LiveUpdate', {b, tick, 0, 1, {'original line 1555'}})
     command('normal! jj8X')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 2, 1, {'origin3'}})
+    expectn('LiveUpdate', {b, tick, 2, 3, {'origin3'}})
 
     -- modify multiple lines at once using visual block mode
     tick = reopen(b, origlines)
@@ -245,19 +245,19 @@ describe('liveupdate', function()
     sendkeys('\x16jjllx')
     tick = tick + 1
     expectn('LiveUpdate',
-            {b, tick, 2, 3, {'original e 3', 'original e 4', 'original e 5'}})
+            {b, tick, 2, 5, {'original e 3', 'original e 4', 'original e 5'}})
 
     -- replace part of a line line using :s
     tick = reopen(b, origlines)
     command('3s/line 3/foo/')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 2, 1, {'original foo'}})
+    expectn('LiveUpdate', {b, tick, 2, 3, {'original foo'}})
 
     -- replace parts of several lines line using :s
     tick = reopen(b, origlines)
     command('%s/line [35]/foo/')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 2, 3, {'original foo',
+    expectn('LiveUpdate', {b, tick, 2, 5, {'original foo',
                                            'original line 4',
                                            'original foo'}})
 
@@ -280,7 +280,7 @@ describe('liveupdate', function()
     expectn('LiveUpdate', {bnew, tick + 4, 0, 1, {'hell'}})
     expectn('LiveUpdate', {bnew, tick + 5, 0, 1, {'hello'}})
     expectn('LiveUpdate', {bnew, tick + 6, 0, 1, {'hello', ''}})
-    expectn('LiveUpdate', {bnew, tick + 7, 1, 1, {'world'}})
+    expectn('LiveUpdate', {bnew, tick + 7, 1, 2, {'world'}})
   end)
 
   it('knows when you replace lines', function()
@@ -289,23 +289,23 @@ describe('liveupdate', function()
     -- blast away parts of some lines with visual mode
     command('normal! jjwvjjllx')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 2, 1, {'original '}})
+    expectn('LiveUpdate', {b, tick, 2, 3, {'original '}})
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 3, 1, {}})
+    expectn('LiveUpdate', {b, tick, 3, 4, {}})
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 3, 1, {'e 5'}})
+    expectn('LiveUpdate', {b, tick, 3, 4, {'e 5'}})
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 2, 1, {'original e 5'}})
+    expectn('LiveUpdate', {b, tick, 2, 3, {'original e 5'}})
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 3, 1, {}})
+    expectn('LiveUpdate', {b, tick, 3, 4, {}})
 
     -- blast away a few lines using :g
     tick = reopen(b, origlines)
     command('global/line [35]/delete')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 2, 1, {}})
+    expectn('LiveUpdate', {b, tick, 2, 3, {}})
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 3, 1, {}})
+    expectn('LiveUpdate', {b, tick, 3, 4, {}})
   end)
 
   it('knows when you filter lines', function()
@@ -317,9 +317,9 @@ describe('liveupdate', function()
     -- 1) addition of the new lines after the filtered lines
     -- 2) removal of the original lines
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 5, 0, {"B", "C", "D", "E"}})
+    expectn('LiveUpdate', {b, tick, 5, 5, {"B", "C", "D", "E"}})
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 1, 4, {}})
+    expectn('LiveUpdate', {b, tick, 1, 5, {}})
   end)
 
   it('sends a sensible event when you use "o"', function()
@@ -329,12 +329,12 @@ describe('liveupdate', function()
     -- use 'o' to start a new line from a line with no indent
     command('normal! o')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 1, 0, {""}})
+    expectn('LiveUpdate', {b, tick, 1, 1, {""}})
 
     -- undo the change, indent line 1 a bit, and try again
     command('undo')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 1, 1, {}})
+    expectn('LiveUpdate', {b, tick, 1, 2, {}})
     tick = tick + 1
     expectn('LiveUpdateTick', {b, tick})
     command('set autoindent')
@@ -343,16 +343,16 @@ describe('liveupdate', function()
     expectn('LiveUpdate', {b, tick, 0, 1, {"\tAAA"}})
     command('normal! ommm')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 1, 0, {"\t"}})
+    expectn('LiveUpdate', {b, tick, 1, 1, {"\t"}})
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 1, 1, {"\tmmm"}})
+    expectn('LiveUpdate', {b, tick, 1, 2, {"\tmmm"}})
 
     -- undo the change, and try again with 'O'
     command('undo')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 1, 1, {'\t'}})
+    expectn('LiveUpdate', {b, tick, 1, 2, {'\t'}})
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 1, 1, {}})
+    expectn('LiveUpdate', {b, tick, 1, 2, {}})
     tick = tick + 1
     expectn('LiveUpdateTick', {b, tick})
     command('normal! ggOmmm')
@@ -556,7 +556,7 @@ describe('liveupdate', function()
     command('normal! G')
     command('diffget')
     tick1 = tick1 + 1
-    expectn('LiveUpdate', {b1, tick1, 2, 0, {"CCC"}})
+    expectn('LiveUpdate', {b1, tick1, 2, 2, {"CCC"}})
 
     eval('rpcnotify('..channel..', "Goodbye")')
     expectn('Goodbye', {})
@@ -574,7 +574,7 @@ describe('liveupdate', function()
     local b, tick = editoriginal(true, {" A", "  B", "B", "\tB", "\t\tC"})
     command('2,4left')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 1, 3, {"B", "B", "B"}})
+    expectn('LiveUpdate', {b, tick, 1, 4, {"B", "B", "B"}})
   end)
 
   it('works with :right', function()
@@ -586,7 +586,7 @@ describe('liveupdate', function()
     command('set ts=2 et')
     command('2,4retab')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 1, 3, {"    B", "      BB", "  B"}})
+    expectn('LiveUpdate', {b, tick, 1, 4, {"    B", "      BB", "  B"}})
   end)
 
   it('works with :move', function()
@@ -594,19 +594,19 @@ describe('liveupdate', function()
     -- move text down towards the end of the file
     command('2,3move 4')
     tick = tick + 2
-    expectn('LiveUpdate', {b, tick, 4, 0, {"original line 2",
+    expectn('LiveUpdate', {b, tick, 4, 4, {"original line 2",
                                            "original line 3"}})
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 1, 2, {}})
+    expectn('LiveUpdate', {b, tick, 1, 3, {}})
 
     -- move text up towards the start of the file
     tick = reopen(b, origlines)
     command('4,5move 2')
     tick = tick + 2
-    expectn('LiveUpdate', {b, tick, 2, 0, {"original line 4",
+    expectn('LiveUpdate', {b, tick, 2, 2, {"original line 4",
                                            "original line 5"}})
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 5, 2, {}})
+    expectn('LiveUpdate', {b, tick, 5, 7, {}})
   end)
 
   it('sends sensible events when you manually add/remove folds', function()
@@ -616,7 +616,7 @@ describe('liveupdate', function()
     -- delete the inner fold
     command('normal! zR3Gzd')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 1, 3, {'original line 2',
+    expectn('LiveUpdate', {b, tick, 1, 4, {'original line 2',
                                            'original line 3',
                                            'original line 4'}})
     -- delete the outer fold
@@ -643,12 +643,12 @@ describe('liveupdate', function()
     -- create a fold from line 4 to the end of the file
     command('normal! 4GA/*{{{*/')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 3, 1, {'original line 4/*{{{*/'}})
+    expectn('LiveUpdate', {b, tick, 3, 4, {'original line 4/*{{{*/'}})
 
     -- delete the fold which only has one marker
     command('normal! Gzd')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 3, 3, {'original line 4',
+    expectn('LiveUpdate', {b, tick, 3, 6, {'original line 4',
                                            'original line 5',
                                            'original line 6'}})
   end)

From 61f467499b6b1bbadda7100fc0c2f0ac4c77a933 Mon Sep 17 00:00:00 2001
From: KillTheMule <KillTheMule@users.noreply.github.com>
Date: Sun, 28 Jan 2018 14:41:32 +0100
Subject: [PATCH 10/26] Bump up buffer capacity to 2GB

---
 src/nvim/event/wstream.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/nvim/event/wstream.c b/src/nvim/event/wstream.c
index d2fb52243c..2baa667e7d 100644
--- a/src/nvim/event/wstream.c
+++ b/src/nvim/event/wstream.c
@@ -14,7 +14,7 @@
 #include "nvim/vim.h"
 #include "nvim/memory.h"
 
-#define DEFAULT_MAXMEM 1024 * 1024 * 10
+#define DEFAULT_MAXMEM 1024 * 1024 * 2000
 
 typedef struct {
   Stream *stream;

From ec215a19621d06791d6ea3a5451e5c775620bc47 Mon Sep 17 00:00:00 2001
From: KillTheMule <KillTheMule@users.noreply.github.com>
Date: Sun, 28 Jan 2018 14:53:38 +0100
Subject: [PATCH 11/26] Fix tests on windows

`cat` is distributed with neovim, so when can use it everywhere, as
opposed to `sort`.

The diffget test fails for unknown reasons on appveyor, mark it pending
for now.
---
 test/functional/api/liveupdate_spec.lua | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/test/functional/api/liveupdate_spec.lua b/test/functional/api/liveupdate_spec.lua
index 6e5221853d..e674913464 100644
--- a/test/functional/api/liveupdate_spec.lua
+++ b/test/functional/api/liveupdate_spec.lua
@@ -309,15 +309,15 @@ describe('liveupdate', function()
   end)
 
   it('knows when you filter lines', function()
-    -- Test filtering lines with !sort
+    -- Test filtering lines with !cat
     local b, tick = editoriginal(true, {"A", "C", "E", "B", "D", "F"})
 
-    command('silent 2,5!sort')
+    command('silent 2,5!cat')
     -- the change comes through as two changes:
     -- 1) addition of the new lines after the filtered lines
     -- 2) removal of the original lines
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 5, 5, {"B", "C", "D", "E"}})
+    expectn('LiveUpdate', {b, tick, 5, 5, {"C", "E", "B", "D"}})
     tick = tick + 1
     expectn('LiveUpdate', {b, tick, 1, 5, {}})
   end)
@@ -462,17 +462,13 @@ describe('liveupdate', function()
   it('is able to notify several channels at once', function()
     helpers.clear()
 
-    local addsession = function(where)
-      eval('serverstart("'..where..'")')
-      local session = helpers.connect(where)
-      return session
-    end
-
     -- create several new sessions, in addition to our main API
     local sessions = {}
-    sessions[1] = addsession(helpers.tmpname()..'.1')
-    sessions[2] = addsession(helpers.tmpname()..'.2')
-    sessions[3] = addsession(helpers.tmpname()..'.3')
+    local pipe = helpers.new_pipename()
+    eval("serverstart('"..pipe.."')")
+    sessions[1] = helpers.connect(pipe)
+    sessions[2] = helpers.connect(pipe)
+    sessions[3] = helpers.connect(pipe)
 
     local function request(sessionnr, method, ...)
       local status, rv = sessions[sessionnr]:request(method, ...)
@@ -539,6 +535,10 @@ describe('liveupdate', function()
   end)
 
   it('works with :diffput and :diffget', function()
+    if os.getenv("APPVEYOR") then
+      pending("Fails on appveyor for some reason.", function() end)
+    end
+
     local b1, tick1 = editoriginal(true, {"AAA", "BBB"})
     local channel = nvim('get_api_info')[1]
     command('diffthis')

From 995a2fad8c32b2063a600ffb8fef1c01100b8ac6 Mon Sep 17 00:00:00 2001
From: KillTheMule <KillTheMule@users.noreply.github.com>
Date: Mon, 29 Jan 2018 19:50:45 +0100
Subject: [PATCH 12/26] Fix memory leak

---
 src/nvim/liveupdate.c | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/nvim/liveupdate.c b/src/nvim/liveupdate.c
index 6bff75217b..d587567e3f 100644
--- a/src/nvim/liveupdate.c
+++ b/src/nvim/liveupdate.c
@@ -98,6 +98,11 @@ void liveupdate_unregister(buf_T *buf, uint64_t channelid)
 
     // make a new copy of the active array without the channelid in it
     liveupdate_send_end(buf, channelid);
+
+    if (found == size) {
+      kv_destroy(buf->liveupdate_channels);
+      kv_init(buf->liveupdate_channels);
+    }
   }
 }
 

From a1d831a49c9428fcbd55d4b06bacca9cb2e9320c Mon Sep 17 00:00:00 2001
From: KillTheMule <KillTheMule@users.noreply.github.com>
Date: Fri, 26 Jan 2018 16:19:55 +0100
Subject: [PATCH 13/26] Doc

---
 runtime/doc/msgpack_rpc.txt | 262 +++++++++++++++++-------------------
 1 file changed, 121 insertions(+), 141 deletions(-)

diff --git a/runtime/doc/msgpack_rpc.txt b/runtime/doc/msgpack_rpc.txt
index e7c80236f8..8781c4589c 100644
--- a/runtime/doc/msgpack_rpc.txt
+++ b/runtime/doc/msgpack_rpc.txt
@@ -244,40 +244,124 @@ connect to another with different type codes.
 ==============================================================================
 6. Live Updates				      *live-updates* *rpc-live-updates*
 
-A dedicated API has been created to allow co-processes to be notified in
-real-time when the user changes a buffer in any way. It is difficult and
-error-prone to try and do this with autocommands such as |TextChanged|.
+A dedicated API has been created to allow co-processes to be notified  when a
+buffer is changed in any way. It is difficult and error-prone to try and do
+this with autocommands such as |TextChanged|.
 
-							*live-updates-enabling*
-Setting Up~
+                                                              *live-updates-api*
+LiveUpdate Functions~
 
-If your API client is a standalone co-process, it can use the
-`"nvim_buf_live_updates"`API method to activate Live Update events for a
-specific buffer. For example, in python >
+nvim_buf_live_updates_start({send_buffer})     *nvim_buf_live_updates_start()*
+              Register a plugin to receive notifications on buffer changes. An
+              initial |LiveUpdateStart| notification will be sent as a
+              confirmation. After that, |LiveUpdate| notifications will be
+              sent for buffer updates, and |LiveUpdateTick| notifications for
+              a new changedtick without buffer change.
 
-	import sys, neovim
-	nvim = neovim.attach('stdio')
-	bufnr = sys.argv[1]
-	nvim.buffers[bufnr].live_updates_start(True)
+              Parameters:~
+                  {send_buffer}  Bool. If `"True"`, the initial
+                  |LiveUpdateStart| notification will also send the full
+                  buffer's content. If `"False"`, the notification will
+                  contain an empty list instead.
 
-After the `"nvim_buf_live_updates_start"` method is called with Argument `"True"`,
-neovim will send a series of notifications containing the entire buffer's
-contents and any subsequent changes. The buffer's contents are sent via
-notifications because if you were to use the other API methods to retrieve the
-buffer contents, the buffer could be changed again before you turn on live
-updates. This can cause a delay if your plugin activates live updates for a
-very large buffer, but it is the the most efficient way to maintain a copy of
-the entire buffer's contents inside your plugin.
+nvim_buf_live_updates_stop()                    *nvim_buf_live_updates_stop()*
+              Unregister a plugin from buffer change notifications. A final
+              |LiveUpdateEnd| notification will be sent as confirmation.
 
-						      *live-updates-disabling*
-Turning Off~
+                                                           *live-updates-events*
+LiveUpdate Events~
 
-You can use `"nvim_buf_live_updates_stop"` to turn off notifications. One
-final notification will be sent to indicate that live updates are no longer
-active for the specified buffer. Alternatively, you can just close the
-channel.
+The co-process will start receiving the following notification events:
 
-						    *live-updates-limitations*
+LiveUpdateStart[{buf}, {changedtick}, {linedata}, {more}]	 *LiveUpdateStart*
+
+  Neovim will send at least one of these notifications to confirm that
+  liveupdates are registered for this plugin, and possibly send the buffer's
+  contents. If the buffer is very large, neovim might send the contents through
+  in multiple events to avoid loading the entire buffer's contents into memory
+  at once.
+
+	{buf} is an API handle for the buffer.
+
+	{changedtick} is the value of |b:changedtick| for the buffer. If you
+	send an API command back to neovim you can check the value of
+	|b:changedtick| as part of your request to ensure that no other
+	changes have been made. 
+
+	{linedata} is a list of strings containing the buffer's contents. If
+	this list contains 100 strings, then they represent lines 1-100 of the
+	buffer.  Newline characters are not included in the strings, so empty
+	lines will be given as empty strings. If you receive another
+	|LiveUpdateStart| notification with another {linedata} list, then
+	these lines represent the next N lines of the buffer. I.e., a second
+  notification with another list of 100 strings will represent lines 101-200
+  of the buffer. If you send the |nvim_buf_live_updates_start| request with
+  its argument set to `"False"`, this will be empty.
+
+	{linedata} will always have at least 1 item, but the maximum length is
+	determined by neovim and not guaranteed to be any particular size.
+	Also the number of {linedata} items may vary between notifications, so
+	your plugin must be prepared to receive the line data in whatever size
+	lists neovim decides to split it into.
+
+  {more} is a boolean which tells you whether or not to expect more
+  |LiveUpdateStart| notifications. When {more} is false, you can be certain
+  that you now have the entire buffer's contents.
+
+LiveUpdate[{buf}, {changedtick}, {firstline}, {lastline}, {linedata}] *LiveUpdate*
+
+  Indicates that the lines between {firstline} and {lastline} (end-exclusive,
+  zero-indexed) have been replaced with the new line data contained in the
+  {linedata} list.  All buffer changes (even adding single characters) will be
+  transmitted as whole-line changes.
+
+	{buf} is an API handle for the buffer.
+
+  {changedtick} is the value of |b:changedtick| for the buffer. If you send an
+  API command back to neovim you can check the value of |b:changedtick| as
+  part of your request to ensure that no other changes have been made.
+
+  {firstline} is the integer line number of the first line that was replaced.
+  Note that {firstline} is zero-indexed, so if line `1` was replaced then
+  {firstline} will be `0` instead of `1`. {firstline} is guaranteed to always
+  be less than or equal to the number of lines that were in the buffer before
+  the lines were replaced.
+
+  {lastline} is the integer line number of the first line that was not
+  replaced (i.e. the range {firstline}, {lastline} is end-exclusive). Note
+  that {lastline} is zero-indexed, so if line numbers 2 to 5 were replaced,
+  this will be `5` instead of `6`. {lastline} is guaranteed to always be less
+  than or equal to the number of lines that were in the buffer before the
+  lines were replaced.
+
+  {linedata} is a list of strings containing the contents of the new buffer
+  lines. Newline characters are not included in the strings, so empty lines
+  will be given as empty strings. 
+
+  Note: sometimes {changedtick} will be |v:null|, which means that the buffer
+  text *looks* like it has changed, but actually hasn't. In this case the
+  lines in {linedata} contain the modified text that is shown to the user, but
+  doesn't reflect the actual buffer contents. Currently this behaviour is only
+  used for the 'inccommand' option.
+
+LiveUpdateTick[{buf}, {changedtick}]		                   *LiveUpdateTick*
+
+  Indicates that |b:changedtick| was incremented for the buffer {buf}, but no
+  text was changed. This is currently only used by undo/redo.
+
+  {buf} is an API handle for the buffer.
+
+  {changedtick} is the new value of |b:changedtick| for that buffer.
+
+LiveUpdateEnd[{buf}]                                    		*LiveUpdateEnd*
+
+  {buf} is an API handle for the buffer.
+
+  Indicates that live updates for the nominated buffer have been disabled,
+  either by calling |nvim_buf_live_updates_stop| or because the buffer was
+  unloaded (see |live-updates-limitations| for more information).
+
+                                                      *live-updates-limitations*
 Limitations~
 
 Note that any of the following actions will also turn off live updates because
@@ -287,146 +371,42 @@ the buffer contents are unloaded from memory:
   - Using |:edit| to reload the buffer
   - reloading the buffer after it is changed from outside neovim.
 
-							  *live-updates-events*
-Handling Events~
-
-The co-process will start receiving the notification events which will be
-equivilent to the following |rpcnotify()| calls:
-
-1. rpcnotify({channel}, "LiveUpdateStart",		      *LiveUpdateStart*
-             [{buf}, {changedtick}, {linedata}, {more}])
-
-	Neovim will send at least one of these notifications to provide you
-	with the original buffer contents. If the buffer is very large, neovim
-	will send the contents through in multiple events to avoid loading the
-	entire buffer's contents into memory at once.
-
-	{buf} is an API handle for the buffer.
-
-	{changedtick} is the value of |b:changedtick| for the buffer. If you
-	send an API command back to neovim you can check the value of
-	|b:changedtick| as part of your request to ensure that no other
-	changes have been made. See |live-update-race-conditions| for more
-	information.
-
-	{linedata} is a list of strings containing the buffer's contents. If
-	this list contains 100 strings, then they represent lines 1-100 of the
-	buffer.  Newline characters are not included in the strings, so empty
-	lines will be given as empty strings. If you receive another
-	`"LiveUpdateStart"` notification with another {linedata} list, then
-	these lines represent the next N lines of the buffer. I.e., a second
-	notification with another list of 100 strings will represent lines
-	101-200 of the buffer.
-
-	{linedata} will always have at least 1 item, but the maximum length is
-	determined by neovim and not guaranteed to be any particular size.
-	Also the number of {linedata} items may vary between notifications, so
-	your plugin must be prepared to receive the line data in whatever size
-	lists neovim decides to split it into.
-
-	{more} is a boolean which tells you whether or not to expect more
-	`"LiveUpdateStart"` notifications. When {more} is false, you can
-	be certain that you now have the entire buffer's contents.
-
-2. rpcnotify({channel}, "LiveUpdate",				  *LiveUpdate*
-	     [{buf}, {changedtick}, {firstline}, {lastline}, {linedata}])
-
-  Indicates that the lines between {firstline} and {lastline} (end-exclusive,
-  zero-indexed) have been replaced with the new line data contained in the
-  {linedata} list.  All buffer changes (even adding single characters) will be
-  transmitted as whole-line changes.
-
-	{buf} is an API handle for the buffer.
-
-	{changedtick} is the value of |b:changedtick| for the buffer. If you
-	send an API command back to neovim you can check the value of
-	|b:changedtick| as part of your request to ensure that no other
-	changes have been made.
-
-	{firstline} is the integer line number of the first line that was
-	replaced. Note that {firstline} is zero-indexed, so if line `1` was
-	replaced then {firstline} will be `0` instead of `1`. {firstline} is
-	guaranteed to always be less than or equal to the number of lines that
-	were in the buffer before the lines were replaced.
-
-  {lastline} is the integer line number of the first line that was not
-  replaced. Note that {lastline} is zero-indexed, so if line numbers 2 to 5
-  were replaced, this will be `5` instead of `6`. {lastline} is guaranteed to
-  always be less than or equal to the number of lines that were in the buffer
-  before the lines were replaced.
-
-	{linedata} is a list of strings containing the contents of the new
-	buffer lines. Newline characters are not included in the strings, so
-	empty lines will be given as empty strings. If {numreplaced} is `1` or
-	more, then {linedata} may be an empty list (indicating that lines were
-	deleted from the buffer). But if {numreplaced} is `0` (indicating that
-	lines were added to the buffer) then {linedata} is guaranteed to
-	contain at least 1 item.
-
-	Note: sometimes {changedtick} will be |v:null|, which means that the
-	buffer text *looks* like it has changed, but actually hasn't. In this
-	case the lines in {linedata} contain the modified text that is shown
-	to the user, but doesn't reflect the actual buffer contents. Currently
-	this behaviour is only used for the 'inccommand' option.
-
-3. rpcnotify({channel}, "LiveUpdateTick",		      *LiveUpdateTick*
-	     [{buf}, {changedtick}])
-
-	Indicates that |b:changedtick| was incremented for the buffer {buf},
-	but no text was changed. This is currently only used by undo/redo.
-
-	{buf} is an API handle for the buffer.
-
-	{changedtick} is the new value of |b:changedtick| for that buffer.
-
-4. rpcnotify({channel}, "LiveUpdateEnd", [{buf}])		*LiveUpdateEnd*
-
-	{buf} is an API handle for the buffer.
-
-	Indicates that live updates for the nominated buffer have been
-	disabled, either by calling the api function `"nvim_buf_live_updates"`
-	with argument `false`, or because the buffer was unloaded (see
-	|live-updates-disabling| and |live-updates-limitations| for more
-	information).
-
-							*live-updates-examples*
+                                                       *live-updates-examples*
 Example Events~
 
 If live updates are activated a new empty buffer, the following
 |LiveUpdateStart| event will be sent: >
 
-	rpcnotify({channel}, "LiveUpdateStart", [{buf}, [""], v:false])
+  rpcnotify({channel}, "LiveUpdateStart", [{buf}, [""], v:false])
 
 If the user adds 2 new lines to the start of a buffer, the following event
 would be generated: >
 
-	rpcnotify({channel}, "LiveUpdate", [{buf}, 0, 0, ["line1", "line2"]])
+  rpcnotify({channel}, "LiveUpdate", [{buf}, 0, 0, ["line1", "line2"]])
 
 If the puts the cursor on a line containing the text `"Hello world"` and adds
 a `!` character to the end using insert mode, the following event would be
 generated: >
 
-	rpcnotify({channel}, "LiveUpdate",
-		  [{buf}, {linenr}, 1, ["Hello world!"]])
+  rpcnotify({channel}, "LiveUpdate", [{buf}, {linenr}, {linenr} + 1, ["Hello
+  world!"]])
 
 If the user moves their cursor to line 3 of a buffer and deletes 20 lines
 using `20dd`, the following event will be generated: >
 
-	rpcnotify({channel}, "LiveUpdate", [{buf}, 2, 20, []])
+  rpcnotify({channel}, "LiveUpdate", [{buf}, 2, 20, []])
 
 If the user selects lines 3-5 of a buffer using |linewise-visual| mode and
 then presses `p` to paste in a new block of 6 lines, then the following event
 would be sent to the co-process: >
 
-	rpcnotify({channel}, "LiveUpdate",
-		  [{buf}, 2, 3, ['pasted line 1', 'pasted line 2',
-				 'pasted line 3', 'pasted line 4',
-				 'pasted line 5', 'pasted line 6']])
+  rpcnotify({channel}, "LiveUpdate", [{buf}, 2, 5, ['pasted line 1', 'pasted
+  line 2', 'pasted line 3', 'pasted line 4', 'pasted line 5', 'pasted line
+  6']])
 
 If the user uses :edit to reload a buffer then the following event would be
 generated: >
 
-	rpcnotify({channel}, "LiveUpdateEnd", [{buf}])
-
+  rpcnotify({channel}, "LiveUpdateEnd", [{buf}])
 
  vim:tw=78:ts=8:ft=help:norl:

From 6bdcbef2f5acfd9815599c751bd8dcbe3204281f Mon Sep 17 00:00:00 2001
From: KillTheMule <KillTheMule@users.noreply.github.com>
Date: Sun, 11 Feb 2018 22:51:29 +0100
Subject: [PATCH 14/26] The grand renaming

---
 runtime/doc/msgpack_rpc.txt                   | 122 ++++----
 src/nvim/CMakeLists.txt                       |   2 +-
 src/nvim/api/buffer.c                         |  28 +-
 src/nvim/buffer.c                             |  10 +-
 src/nvim/buffer_defs.h                        |   4 +-
 src/nvim/{liveupdate.c => buffer_updates.c}   |  62 ++--
 src/nvim/buffer_updates.h                     |  13 +
 src/nvim/ex_cmds.c                            |  24 +-
 src/nvim/fold.c                               |  14 +-
 src/nvim/liveupdate.h                         |  13 -
 src/nvim/misc1.c                              |  14 +-
 src/nvim/terminal.c                           |   2 +-
 src/nvim/undo.c                               |  20 +-
 ...pdate_spec.lua => buffer_updates_spec.lua} | 294 +++++++++---------
 14 files changed, 311 insertions(+), 311 deletions(-)
 rename src/nvim/{liveupdate.c => buffer_updates.c} (73%)
 create mode 100644 src/nvim/buffer_updates.h
 delete mode 100644 src/nvim/liveupdate.h
 rename test/functional/api/{liveupdate_spec.lua => buffer_updates_spec.lua} (67%)

diff --git a/runtime/doc/msgpack_rpc.txt b/runtime/doc/msgpack_rpc.txt
index 8781c4589c..bf7c63710f 100644
--- a/runtime/doc/msgpack_rpc.txt
+++ b/runtime/doc/msgpack_rpc.txt
@@ -242,44 +242,44 @@ the type codes, because a client may be built against one Nvim version but
 connect to another with different type codes.
 
 ==============================================================================
-6. Live Updates				      *live-updates* *rpc-live-updates*
+6. Buffer Updates				      *buffer-updates* *rpc-buffer-updates*
 
 A dedicated API has been created to allow co-processes to be notified  when a
 buffer is changed in any way. It is difficult and error-prone to try and do
 this with autocommands such as |TextChanged|.
 
-                                                              *live-updates-api*
-LiveUpdate Functions~
+                                                              *buffer-updates-api*
+BufferUpdates Functions~
 
-nvim_buf_live_updates_start({send_buffer})     *nvim_buf_live_updates_start()*
+nvim_buf_attach({send_buffer})                                *nvim_buf_attach()*
               Register a plugin to receive notifications on buffer changes. An
-              initial |LiveUpdateStart| notification will be sent as a
-              confirmation. After that, |LiveUpdate| notifications will be
-              sent for buffer updates, and |LiveUpdateTick| notifications for
-              a new changedtick without buffer change.
+              initial |nvim_buf_updates_start| notification will be sent as a
+              confirmation. After that, |nvim_buf_update| notifications will be
+              sent for buffer updates, and |nvim_buf_update_tick| notifications
+              for a new changedtick without buffer change.
 
               Parameters:~
                   {send_buffer}  Bool. If `"True"`, the initial
-                  |LiveUpdateStart| notification will also send the full
-                  buffer's content. If `"False"`, the notification will
-                  contain an empty list instead.
+                  |nvim_buf_updates_start| notification will also send the full
+                  buffer's content. If `"False"`, the notification will contain
+                  an empty list instead.
 
-nvim_buf_live_updates_stop()                    *nvim_buf_live_updates_stop()*
+nvim_buf_detach()                                            *nvim_buf_detach()*
               Unregister a plugin from buffer change notifications. A final
-              |LiveUpdateEnd| notification will be sent as confirmation.
+              |nvim_buf_updates_end| notification will be sent as confirmation.
 
-                                                           *live-updates-events*
-LiveUpdate Events~
+                                                           *buffer-updates-events*
+BufferUpdates Events~
 
 The co-process will start receiving the following notification events:
 
-LiveUpdateStart[{buf}, {changedtick}, {linedata}, {more}]	 *LiveUpdateStart*
+nvim_buf_updates_start[{buf}, {changedtick}, {linedata}, {more}]	 *nvim_buf_updates_start*
 
   Neovim will send at least one of these notifications to confirm that
-  liveupdates are registered for this plugin, and possibly send the buffer's
+  buffer updates are registered for this plugin, and possibly send the buffer's
   contents. If the buffer is very large, neovim might send the contents through
-  in multiple events to avoid loading the entire buffer's contents into memory
-  at once.
+  in multiple events to avoid loading the entire buffer's contents into
+  memory at once.
 
 	{buf} is an API handle for the buffer.
 
@@ -288,27 +288,27 @@ LiveUpdateStart[{buf}, {changedtick}, {linedata}, {more}]	 *LiveUpdateStart*
 	|b:changedtick| as part of your request to ensure that no other
 	changes have been made. 
 
-	{linedata} is a list of strings containing the buffer's contents. If
-	this list contains 100 strings, then they represent lines 1-100 of the
-	buffer.  Newline characters are not included in the strings, so empty
-	lines will be given as empty strings. If you receive another
-	|LiveUpdateStart| notification with another {linedata} list, then
-	these lines represent the next N lines of the buffer. I.e., a second
-  notification with another list of 100 strings will represent lines 101-200
-  of the buffer. If you send the |nvim_buf_live_updates_start| request with
-  its argument set to `"False"`, this will be empty.
+  {linedata} is a list of strings containing the buffer's contents. If this
+  list contains 100 strings, then they represent lines 1-100 of the buffer.
+  Newline characters are not included in the strings, so empty lines will be
+  given as empty strings. If you receive another |nvim_buf_updates_start|
+  notification with another {linedata} list, then these lines represent the
+  next N lines of the buffer. I.e., a second notification with another list of
+  100 strings will represent lines 101-200 of the buffer. If you send the
+  |nvim_buf_updates_start| request with its argument set to `"False"`, this
+  will be empty.
 
-	{linedata} will always have at least 1 item, but the maximum length is
-	determined by neovim and not guaranteed to be any particular size.
-	Also the number of {linedata} items may vary between notifications, so
-	your plugin must be prepared to receive the line data in whatever size
-	lists neovim decides to split it into.
+  {linedata} will always have at least 1 item, but the maximum length is
+  determined by neovim and not guaranteed to be any particular size.  Also the
+  number of {linedata} items may vary between notifications, so your plugin
+  must be prepared to receive the line data in whatever size lists neovim
+  decides to split it into.
 
   {more} is a boolean which tells you whether or not to expect more
-  |LiveUpdateStart| notifications. When {more} is false, you can be certain
+  |nvim_buf_updates_start| notifications. When {more} is false, you can be certain
   that you now have the entire buffer's contents.
 
-LiveUpdate[{buf}, {changedtick}, {firstline}, {lastline}, {linedata}] *LiveUpdate*
+nvim_buf_update[{buf}, {changedtick}, {firstline}, {lastline}, {linedata}] *nvim_buf_update*
 
   Indicates that the lines between {firstline} and {lastline} (end-exclusive,
   zero-indexed) have been replaced with the new line data contained in the
@@ -327,24 +327,24 @@ LiveUpdate[{buf}, {changedtick}, {firstline}, {lastline}, {linedata}] *LiveUpdat
   be less than or equal to the number of lines that were in the buffer before
   the lines were replaced.
 
-  {lastline} is the integer line number of the first line that was not
-  replaced (i.e. the range {firstline}, {lastline} is end-exclusive). Note
-  that {lastline} is zero-indexed, so if line numbers 2 to 5 were replaced,
-  this will be `5` instead of `6`. {lastline} is guaranteed to always be less
-  than or equal to the number of lines that were in the buffer before the
-  lines were replaced.
+  {lastline} is the integer line number of the first line that was not replaced
+  (i.e. the range {firstline}, {lastline} is end-exclusive). Note that
+  {lastline} is zero-indexed, so if line numbers 2 to 5 were replaced, this
+  will be `5` instead of `6`. {lastline} is guaranteed to always be less than
+  or equal to the number of lines that were in the buffer before the lines were
+  replaced.
 
   {linedata} is a list of strings containing the contents of the new buffer
   lines. Newline characters are not included in the strings, so empty lines
   will be given as empty strings. 
 
   Note: sometimes {changedtick} will be |v:null|, which means that the buffer
-  text *looks* like it has changed, but actually hasn't. In this case the
-  lines in {linedata} contain the modified text that is shown to the user, but
-  doesn't reflect the actual buffer contents. Currently this behaviour is only
-  used for the 'inccommand' option.
+  text *looks* like it has changed, but actually hasn't. In this case the lines
+  in {linedata} contain the modified text that is shown to the user, but
+  doesn't reflect the actual buffer contents. Currently this behaviour is
+  only used for the 'inccommand' option.
 
-LiveUpdateTick[{buf}, {changedtick}]		                   *LiveUpdateTick*
+nvim_buf_update_tick[{buf}, {changedtick}]		                   *nvim_buf_update_tick*
 
   Indicates that |b:changedtick| was incremented for the buffer {buf}, but no
   text was changed. This is currently only used by undo/redo.
@@ -353,60 +353,60 @@ LiveUpdateTick[{buf}, {changedtick}]		                   *LiveUpdateTick*
 
   {changedtick} is the new value of |b:changedtick| for that buffer.
 
-LiveUpdateEnd[{buf}]                                    		*LiveUpdateEnd*
+nvim_buf_updates_end[{buf}]                                    		*nvim_buf_updates_end*
 
   {buf} is an API handle for the buffer.
 
-  Indicates that live updates for the nominated buffer have been disabled,
-  either by calling |nvim_buf_live_updates_stop| or because the buffer was
-  unloaded (see |live-updates-limitations| for more information).
+  Indicates that buffer updates for the nominated buffer have been disabled,
+  either by calling |nvim_buf_detach| or because the buffer was unloaded
+  (see |buffer-updates-limitations| for more information).
 
-                                                      *live-updates-limitations*
+                                                      *buffer-updates-limitations*
 Limitations~
 
-Note that any of the following actions will also turn off live updates because
+Note that any of the following actions will also turn off buffer updates because
 the buffer contents are unloaded from memory:
 
   - Closing all a buffer's windows (unless 'hidden' is enabled).
   - Using |:edit| to reload the buffer
   - reloading the buffer after it is changed from outside neovim.
 
-                                                       *live-updates-examples*
+                                                       *buffer-updates-examples*
 Example Events~
 
-If live updates are activated a new empty buffer, the following
-|LiveUpdateStart| event will be sent: >
+If buffer updates are activated a new empty buffer, the following
+|nvim_buf_updates_start| event will be sent: >
 
-  rpcnotify({channel}, "LiveUpdateStart", [{buf}, [""], v:false])
+  rpcnotify({channel}, "nvim_buf_updates_start", [{buf}, [""], v:false])
 
 If the user adds 2 new lines to the start of a buffer, the following event
 would be generated: >
 
-  rpcnotify({channel}, "LiveUpdate", [{buf}, 0, 0, ["line1", "line2"]])
+  rpcnotify({channel}, "nvim_buf_update", [{buf}, 0, 0, ["line1", "line2"]])
 
 If the puts the cursor on a line containing the text `"Hello world"` and adds
 a `!` character to the end using insert mode, the following event would be
 generated: >
 
-  rpcnotify({channel}, "LiveUpdate", [{buf}, {linenr}, {linenr} + 1, ["Hello
+  rpcnotify({channel}, "nvim_buf_update", [{buf}, {linenr}, {linenr} + 1, ["Hello
   world!"]])
 
 If the user moves their cursor to line 3 of a buffer and deletes 20 lines
 using `20dd`, the following event will be generated: >
 
-  rpcnotify({channel}, "LiveUpdate", [{buf}, 2, 20, []])
+  rpcnotify({channel}, "nvim_buf_update", [{buf}, 2, 20, []])
 
 If the user selects lines 3-5 of a buffer using |linewise-visual| mode and
 then presses `p` to paste in a new block of 6 lines, then the following event
 would be sent to the co-process: >
 
-  rpcnotify({channel}, "LiveUpdate", [{buf}, 2, 5, ['pasted line 1', 'pasted
+  rpcnotify({channel}, "nvim_buf_update", [{buf}, 2, 5, ['pasted line 1', 'pasted
   line 2', 'pasted line 3', 'pasted line 4', 'pasted line 5', 'pasted line
   6']])
 
 If the user uses :edit to reload a buffer then the following event would be
 generated: >
 
-  rpcnotify({channel}, "LiveUpdateEnd", [{buf}])
+  rpcnotify({channel}, "nvim_buf_updates_end", [{buf}])
 
  vim:tw=78:ts=8:ft=help:norl:
diff --git a/src/nvim/CMakeLists.txt b/src/nvim/CMakeLists.txt
index a8a52a8093..97495eec6d 100644
--- a/src/nvim/CMakeLists.txt
+++ b/src/nvim/CMakeLists.txt
@@ -142,7 +142,7 @@ set(CONV_SOURCES
   message.c
   regexp.c
   screen.c
-  liveupdate.c
+  buffer_updates.c
   search.c
   spell.c
   spellfile.c
diff --git a/src/nvim/api/buffer.c b/src/nvim/api/buffer.c
index 6778227a27..d59ce1ce3d 100644
--- a/src/nvim/api/buffer.c
+++ b/src/nvim/api/buffer.c
@@ -25,7 +25,7 @@
 #include "nvim/window.h"
 #include "nvim/undo.h"
 #include "nvim/ex_docmd.h"
-#include "nvim/liveupdate.h"
+#include "nvim/buffer_updates.h"
 
 #ifdef INCLUDE_GENERATED_DECLARATIONS
 # include "api/buffer.c.generated.h"
@@ -76,18 +76,18 @@ String buffer_get_line(Buffer buffer, Integer index, Error *err)
   return rv;
 }
 
-/// Activate live updates from this buffer to the current channel.
+/// Activate updates from this buffer to the current channel.
 ///
 /// @param buffer The buffer handle
 /// @param send_buffer Set to true if the initial notification should contain
 ///        the whole buffer
 /// @param[out] err Details of an error that may have occurred
-/// @return False when live updates couldn't be enabled because the buffer isn't
+/// @return False when updates couldn't be enabled because the buffer isn't
 ///         loaded; otherwise True.
-Boolean nvim_buf_live_updates_start(uint64_t channel_id,
-                                    Buffer buffer,
-                                    Boolean send_buffer,
-                                    Error *err)
+Boolean nvim_buf_attach(uint64_t channel_id,
+                                 Buffer buffer,
+                                 Boolean send_buffer,
+                                 Error *err)
   FUNC_API_SINCE(4) FUNC_API_REMOTE_ONLY
 {
   buf_T *buf = find_buffer_by_handle(buffer, err);
@@ -96,18 +96,18 @@ Boolean nvim_buf_live_updates_start(uint64_t channel_id,
     return false;
   }
 
-  return liveupdate_register(buf, channel_id, send_buffer);
+  return buffer_updates_register(buf, channel_id, send_buffer);
 }
 //
-/// Deactivate live updates from this buffer to the current channel.
+/// Deactivate updates from this buffer to the current channel.
 ///
 /// @param buffer The buffer handle
 /// @param[out] err Details of an error that may have occurred
-/// @return False when live updates couldn't be disabled because the buffer
+/// @return False when updates couldn't be disabled because the buffer
 ///         isn't loaded; otherwise True.
-Boolean nvim_buf_live_updates_stop(uint64_t channel_id,
-                                   Buffer buffer,
-                                   Error *err)
+Boolean nvim_buf_detach(uint64_t channel_id,
+                                 Buffer buffer,
+                                 Error *err)
   FUNC_API_SINCE(4) FUNC_API_REMOTE_ONLY
 {
   buf_T *buf = find_buffer_by_handle(buffer, err);
@@ -116,7 +116,7 @@ Boolean nvim_buf_live_updates_stop(uint64_t channel_id,
     return false;
   }
 
-  liveupdate_unregister(buf, channel_id);
+  buffer_updates_unregister(buf, channel_id);
   return true;
 }
 
diff --git a/src/nvim/buffer.c b/src/nvim/buffer.c
index e7ff25ce6b..e5b7128248 100644
--- a/src/nvim/buffer.c
+++ b/src/nvim/buffer.c
@@ -73,7 +73,7 @@
 #include "nvim/os/os.h"
 #include "nvim/os/time.h"
 #include "nvim/os/input.h"
-#include "nvim/liveupdate.h"
+#include "nvim/buffer_updates.h"
 
 typedef enum {
   kBLSUnchanged = 0,
@@ -576,7 +576,7 @@ void close_buffer(win_T *win, buf_T *buf, int action, int abort_if_last)
   do_autochdir();
 
   // disable live updates for the current buffer
-  liveupdate_unregister_all(buf);
+  buffer_updates_unregister_all(buf);
 
   /*
    * Remove the buffer from the list.
@@ -789,7 +789,7 @@ free_buffer_stuff (
   xfree(buf->b_start_fenc);
   buf->b_start_fenc = NULL;
 
-  liveupdate_unregister_all(buf);
+  buffer_updates_unregister_all(buf);
 }
 
 /*
@@ -1741,8 +1741,8 @@ buf_T * buflist_new(char_u *ffname, char_u *sfname, linenr_T lnum, int flags)
   clrallmarks(buf);                     // clear marks
   fmarks_check_names(buf);              // check file marks for this file
   buf->b_p_bl = (flags & BLN_LISTED) ? true : false;    // init 'buflisted'
-  kv_destroy(buf->liveupdate_channels);
-  kv_init(buf->liveupdate_channels);
+  kv_destroy(buf->update_channels);
+  kv_init(buf->update_channels);
   if (!(flags & BLN_DUMMY)) {
     // Tricky: these autocommands may change the buffer list.  They could also
     // split the window with re-using the one empty buffer. This may result in
diff --git a/src/nvim/buffer_defs.h b/src/nvim/buffer_defs.h
index 9f6ac15308..50d8c822c1 100644
--- a/src/nvim/buffer_defs.h
+++ b/src/nvim/buffer_defs.h
@@ -774,9 +774,9 @@ struct file_buffer {
 
   kvec_t(BufhlLine *) b_bufhl_move_space;  // temporary space for highlights
 
-  // array of channelids which have asked to receive live updates for this
+  // array of channelids which have asked to receive updates for this
   // buffer.
-  kvec_t(uint64_t) liveupdate_channels;
+  kvec_t(uint64_t) update_channels;
 };
 
 /*
diff --git a/src/nvim/liveupdate.c b/src/nvim/buffer_updates.c
similarity index 73%
rename from src/nvim/liveupdate.c
rename to src/nvim/buffer_updates.c
index d587567e3f..d7bb11d125 100644
--- a/src/nvim/liveupdate.c
+++ b/src/nvim/buffer_updates.c
@@ -1,4 +1,4 @@
-#include "nvim/liveupdate.h"
+#include "nvim/buffer_updates.h"
 #include "nvim/memline.h"
 #include "nvim/api/private/helpers.h"
 #include "nvim/msgpack_rpc/channel.h"
@@ -6,7 +6,7 @@
 // Register a channel. Return True if the channel was added, or already added.
 // Return False if the channel couldn't be added because the buffer is
 // unloaded.
-bool liveupdate_register(buf_T *buf, uint64_t channel_id, bool send_buffer)
+bool buffer_updates_register(buf_T *buf, uint64_t channel_id, bool send_buffer)
 {
   // must fail if the buffer isn't loaded
   if (buf->b_ml.ml_mfp == NULL) {
@@ -14,10 +14,10 @@ bool liveupdate_register(buf_T *buf, uint64_t channel_id, bool send_buffer)
   }
 
   // count how many channels are currently watching the buffer
-  size_t size = kv_size(buf->liveupdate_channels);
+  size_t size = kv_size(buf->update_channels);
   if (size) {
     for (size_t i = 0; i < size; i++) {
-      if (kv_A(buf->liveupdate_channels, i) == channel_id) {
+      if (kv_A(buf->update_channels, i) == channel_id) {
         // buffer is already registered ... nothing to do
         return true;
       }
@@ -25,7 +25,7 @@ bool liveupdate_register(buf_T *buf, uint64_t channel_id, bool send_buffer)
   }
 
   // append the channelid to the list
-  kv_push(buf->liveupdate_channels, channel_id);
+  kv_push(buf->update_channels, channel_id);
 
   Array linedata = ARRAY_DICT_INIT;
   if (send_buffer) {
@@ -56,22 +56,22 @@ bool liveupdate_register(buf_T *buf, uint64_t channel_id, bool send_buffer)
   args.items[2] = ARRAY_OBJ(linedata);
   args.items[3] = BOOLEAN_OBJ(false);
 
-  rpc_send_event(channel_id, "LiveUpdateStart", args);
+  rpc_send_event(channel_id, "nvim_buf_updates_start", args);
   return true;
 }
 
-void liveupdate_send_end(buf_T *buf, uint64_t channelid)
+void buffer_updates_send_end(buf_T *buf, uint64_t channelid)
 {
     Array args = ARRAY_DICT_INIT;
     args.size = 1;
     args.items = xcalloc(sizeof(Object), args.size);
     args.items[0] = BUFFER_OBJ(buf->handle);
-    rpc_send_event(channelid, "LiveUpdateEnd", args);
+    rpc_send_event(channelid, "nvim_buf_updates_end", args);
 }
 
-void liveupdate_unregister(buf_T *buf, uint64_t channelid)
+void buffer_updates_unregister(buf_T *buf, uint64_t channelid)
 {
-  size_t size = kv_size(buf->liveupdate_channels);
+  size_t size = kv_size(buf->update_channels);
   if (!size) {
     return;
   }
@@ -81,12 +81,12 @@ void liveupdate_unregister(buf_T *buf, uint64_t channelid)
   size_t j = 0;
   size_t found = 0;
   for (size_t i = 0; i < size; i++) {
-    if (kv_A(buf->liveupdate_channels, i) == channelid) {
+    if (kv_A(buf->update_channels, i) == channelid) {
       found++;
     } else {
       // copy item backwards into prior slot if needed
       if (i != j) {
-        kv_A(buf->liveupdate_channels, j) = kv_A(buf->liveupdate_channels, i);
+        kv_A(buf->update_channels, j) = kv_A(buf->update_channels, i);
       }
       j++;
     }
@@ -94,39 +94,39 @@ void liveupdate_unregister(buf_T *buf, uint64_t channelid)
 
   if (found) {
     // remove X items from the end of the array
-    buf->liveupdate_channels.size -= found;
+    buf->update_channels.size -= found;
 
     // make a new copy of the active array without the channelid in it
-    liveupdate_send_end(buf, channelid);
+    buffer_updates_send_end(buf, channelid);
 
     if (found == size) {
-      kv_destroy(buf->liveupdate_channels);
-      kv_init(buf->liveupdate_channels);
+      kv_destroy(buf->update_channels);
+      kv_init(buf->update_channels);
     }
   }
 }
 
-void liveupdate_unregister_all(buf_T *buf)
+void buffer_updates_unregister_all(buf_T *buf)
 {
-  size_t size = kv_size(buf->liveupdate_channels);
+  size_t size = kv_size(buf->update_channels);
   if (size) {
     for (size_t i = 0; i < size; i++) {
-      liveupdate_send_end(buf, kv_A(buf->liveupdate_channels, i));
+      buffer_updates_send_end(buf, kv_A(buf->update_channels, i));
     }
-    kv_destroy(buf->liveupdate_channels);
-    kv_init(buf->liveupdate_channels);
+    kv_destroy(buf->update_channels);
+    kv_init(buf->update_channels);
   }
 }
 
-void liveupdate_send_changes(buf_T *buf, linenr_T firstline, int64_t num_added,
+void buffer_updates_send_changes(buf_T *buf, linenr_T firstline, int64_t num_added,
                              int64_t num_removed, bool send_tick)
 {
   // if one the channels doesn't work, put its ID here so we can remove it later
   uint64_t badchannelid = 0;
 
   // notify each of the active channels
-  for (size_t i = 0; i < kv_size(buf->liveupdate_channels); i++) {
-    uint64_t channelid = kv_A(buf->liveupdate_channels, i);
+  for (size_t i = 0; i < kv_size(buf->update_channels); i++) {
+    uint64_t channelid = kv_A(buf->update_channels, i);
 
     // send through the changes now channel contents now
     Array args = ARRAY_DICT_INIT;
@@ -162,9 +162,9 @@ void liveupdate_send_changes(buf_T *buf, linenr_T firstline, int64_t num_added,
         }
     }
     args.items[4] = ARRAY_OBJ(linedata);
-    if (!rpc_send_event(channelid, "LiveUpdate", args)) {
+    if (!rpc_send_event(channelid, "nvim_buf_update", args)) {
       // We can't unregister the channel while we're iterating over the
-      // liveupdate_channels array, so we remember its ID to unregister it at
+      // update_channels array, so we remember its ID to unregister it at
       // the end.
       badchannelid = channelid;
     }
@@ -175,15 +175,15 @@ void liveupdate_send_changes(buf_T *buf, linenr_T firstline, int64_t num_added,
   // cleared up quickly.
   if (badchannelid != 0) {
     ELOG("Disabling live updates for dead channel %llu", badchannelid);
-    liveupdate_unregister(buf, badchannelid);
+    buffer_updates_unregister(buf, badchannelid);
   }
 }
 
-void liveupdate_send_tick(buf_T *buf)
+void buffer_updates_send_tick(buf_T *buf)
 {
   // notify each of the active channels
-  for (size_t i = 0; i < kv_size(buf->liveupdate_channels); i++) {
-    uint64_t channelid = kv_A(buf->liveupdate_channels, i);
+  for (size_t i = 0; i < kv_size(buf->update_channels); i++) {
+    uint64_t channelid = kv_A(buf->update_channels, i);
 
     // send through the changes now channel contents now
     Array args = ARRAY_DICT_INIT;
@@ -197,6 +197,6 @@ void liveupdate_send_tick(buf_T *buf)
     args.items[1] = INTEGER_OBJ(buf->b_changedtick);
 
     // don't try and clean up dead channels here
-    rpc_send_event(channelid, "LiveUpdateTick", args);
+    rpc_send_event(channelid, "nvim_buf_update_tick", args);
   }
 }
diff --git a/src/nvim/buffer_updates.h b/src/nvim/buffer_updates.h
new file mode 100644
index 0000000000..8fe33a0ebe
--- /dev/null
+++ b/src/nvim/buffer_updates.h
@@ -0,0 +1,13 @@
+#ifndef BUFFER_UPDATES_H
+#define BUFFER_UPDATES_H
+
+#include "nvim/buffer_defs.h"
+
+bool buffer_updates_register(buf_T *buf, uint64_t channel_id, bool send_buffer);
+void buffer_updates_unregister(buf_T *buf, uint64_t channel_id);
+void buffer_updates_unregister_all(buf_T *buf);
+void buffer_updates_send_changes(buf_T *buf, linenr_T firstline, int64_t num_added,
+                             int64_t num_removed, bool send_tick);
+void buffer_updates_send_tick(buf_T *buf);
+
+#endif  // NVIM_BUFFER_UPDATES_H
diff --git a/src/nvim/ex_cmds.c b/src/nvim/ex_cmds.c
index e418e0c20e..fdb8c87213 100644
--- a/src/nvim/ex_cmds.c
+++ b/src/nvim/ex_cmds.c
@@ -35,7 +35,7 @@
 #include "nvim/fold.h"
 #include "nvim/getchar.h"
 #include "nvim/indent.h"
-#include "nvim/liveupdate.h"
+#include "nvim/buffer_updates.h"
 #include "nvim/main.h"
 #include "nvim/mark.h"
 #include "nvim/mbyte.h"
@@ -833,9 +833,9 @@ int do_move(linenr_T line1, linenr_T line2, linenr_T dest)
                      -(last_line - dest - extra), 0L, true);
   changed_lines(last_line - num_lines + 1, 0, last_line + 1, -extra, false);
 
-  // send live update regarding the new lines that were added
-  if (kv_size(curbuf->liveupdate_channels)) {
-    liveupdate_send_changes(curbuf, dest + 1, num_lines, 0, true);
+  // send update regarding the new lines that were added
+  if (kv_size(curbuf->update_channels)) {
+    buffer_updates_send_changes(curbuf, dest + 1, num_lines, 0, true);
   }
 
   /*
@@ -872,9 +872,9 @@ int do_move(linenr_T line1, linenr_T line2, linenr_T dest)
     changed_lines(dest + 1, 0, line1 + num_lines, 0L, false);
   }
 
-  // send LiveUpdate regarding lines that were deleted
-  if (kv_size(curbuf->liveupdate_channels)) {
-    liveupdate_send_changes(curbuf, line1 + extra, 0, num_lines, true);
+  // send nvim_buf_update regarding lines that were deleted
+  if (kv_size(curbuf->update_channels)) {
+    buffer_updates_send_changes(curbuf, line1 + extra, 0, num_lines, true);
   }
 
   return OK;
@@ -2442,7 +2442,7 @@ int do_ecmd(
         goto theend;
       }
       u_unchanged(curbuf);
-      liveupdate_unregister_all(curbuf);
+      buffer_updates_unregister_all(curbuf);
       buf_freeall(curbuf, BFA_KEEP_UNDO);
 
       // Tell readfile() not to clear or reload undo info.
@@ -3170,7 +3170,7 @@ static char_u *sub_parse_flags(char_u *cmd, subflags_T *subflags,
 ///
 /// @return buffer used for 'inccommand' preview
 static buf_T *do_sub(exarg_T *eap, proftime_T timeout,
-                     bool send_liveupdate_changedtick)
+                     bool send_buffer_update_changedtick)
 {
   long i = 0;
   regmmatch_T regmatch;
@@ -4018,11 +4018,11 @@ skip:
     i = curbuf->b_ml.ml_line_count - old_line_count;
     changed_lines(first_line, 0, last_line - i, i, false);
 
-    if (kv_size(curbuf->liveupdate_channels)) {
+    if (kv_size(curbuf->update_channels)) {
       int64_t num_added = last_line - first_line;
       int64_t num_removed = num_added - i;
-      liveupdate_send_changes(curbuf, first_line, num_added, num_removed,
-                              send_liveupdate_changedtick);
+      buffer_updates_send_changes(curbuf, first_line, num_added, num_removed,
+                              send_buffer_update_changedtick);
     }
   }
 
diff --git a/src/nvim/fold.c b/src/nvim/fold.c
index 5758a298ac..2cf1c6f394 100644
--- a/src/nvim/fold.c
+++ b/src/nvim/fold.c
@@ -20,7 +20,7 @@
 #include "nvim/ex_docmd.h"
 #include "nvim/func_attr.h"
 #include "nvim/indent.h"
-#include "nvim/liveupdate.h"
+#include "nvim/buffer_updates.h"
 #include "nvim/mark.h"
 #include "nvim/memline.h"
 #include "nvim/memory.h"
@@ -746,14 +746,14 @@ deleteFold (
   if (last_lnum > 0) {
     changed_lines(first_lnum, (colnr_T)0, last_lnum, 0L, false);
 
-    // send one LiveUpdate at the end
-    if (kv_size(curbuf->liveupdate_channels)) {
+    // send one nvim_buf_update at the end
+    if (kv_size(curbuf->update_channels)) {
       // last_lnum is the line *after* the last line of the outermost fold
       // that was modified. Note also that deleting a fold might only require
       // the modification of the *first* line of the fold, but we send through a
       // notification that includes every line that was part of the fold
       int64_t num_changed = last_lnum - first_lnum;
-      liveupdate_send_changes(curbuf, first_lnum, num_changed,
+      buffer_updates_send_changes(curbuf, first_lnum, num_changed,
                               num_changed, true);
     }
   }
@@ -1605,12 +1605,12 @@ static void foldCreateMarkers(linenr_T start, linenr_T end)
    * changed when the start marker is inserted and the end isn't. */
   changed_lines(start, (colnr_T)0, end, 0L, false);
 
-  if (kv_size(curbuf->liveupdate_channels)) {
+  if (kv_size(curbuf->update_channels)) {
     // Note: foldAddMarker() may not actually change start and/or end if
-    // u_save() is unable to save the buffer line, but we send the LiveUpdate
+    // u_save() is unable to save the buffer line, but we send the nvim_buf_update
     // anyway since it won't do any harm.
     int64_t num_changed = 1 + end - start;
-    liveupdate_send_changes(curbuf, start, num_changed, num_changed, true);
+    buffer_updates_send_changes(curbuf, start, num_changed, num_changed, true);
   }
 }
 
diff --git a/src/nvim/liveupdate.h b/src/nvim/liveupdate.h
deleted file mode 100644
index 77fb420bf0..0000000000
--- a/src/nvim/liveupdate.h
+++ /dev/null
@@ -1,13 +0,0 @@
-#ifndef NVIM_LIVEUPDATE_H
-#define NVIM_LIVEUPDATE_H
-
-#include "nvim/buffer_defs.h"
-
-bool liveupdate_register(buf_T *buf, uint64_t channel_id, bool send_buffer);
-void liveupdate_unregister(buf_T *buf, uint64_t channel_id);
-void liveupdate_unregister_all(buf_T *buf);
-void liveupdate_send_changes(buf_T *buf, linenr_T firstline, int64_t num_added,
-                             int64_t num_removed, bool send_tick);
-void liveupdate_send_tick(buf_T *buf);
-
-#endif  // NVIM_LIVEUPDATE_H
diff --git a/src/nvim/misc1.c b/src/nvim/misc1.c
index e2094d7293..7c9e728c92 100644
--- a/src/nvim/misc1.c
+++ b/src/nvim/misc1.c
@@ -28,7 +28,7 @@
 #include "nvim/getchar.h"
 #include "nvim/indent.h"
 #include "nvim/indent_c.h"
-#include "nvim/liveupdate.h"
+#include "nvim/buffer_updates.h"
 #include "nvim/main.h"
 #include "nvim/mark.h"
 #include "nvim/mbyte.h"
@@ -1822,8 +1822,8 @@ void changed_bytes(linenr_T lnum, colnr_T col)
   changedOneline(curbuf, lnum);
   changed_common(lnum, col, lnum + 1, 0L);
   // notify any channels that are watching
-  if (kv_size(curbuf->liveupdate_channels)) {
-    liveupdate_send_changes(curbuf, lnum, 1, 1, true);
+  if (kv_size(curbuf->update_channels)) {
+    buffer_updates_send_changes(curbuf, lnum, 1, 1, true);
   }
 
   /* Diff highlighting in other diff windows may need to be updated too. */
@@ -1920,9 +1920,9 @@ changed_lines(
     colnr_T col,          // column in first line with change
     linenr_T lnume,       // line below last changed line
     long xtra,            // number of extra lines (negative when deleting)
-    bool send_liveupdate  // some callers like undo/redo call changed_lines()
+    bool send_update  // some callers like undo/redo call changed_lines()
                           // and then increment b_changedtick *again*. This flag
-                          // allows these callers to send the LiveUpdate events
+                          // allows these callers to send the nvim_buf_update events
                           // after they're done modifying b_changedtick.
 )
 {
@@ -1948,10 +1948,10 @@ changed_lines(
 
   changed_common(lnum, col, lnume, xtra);
 
-  if (send_liveupdate && kv_size(curbuf->liveupdate_channels)) {
+  if (send_update && kv_size(curbuf->update_channels)) {
     int64_t num_added = (int64_t)(lnume + xtra - lnum);
     int64_t num_removed = lnume - lnum;
-    liveupdate_send_changes(curbuf, lnum, num_added, num_removed, true);
+    buffer_updates_send_changes(curbuf, lnum, num_added, num_removed, true);
   }
 }
 
diff --git a/src/nvim/terminal.c b/src/nvim/terminal.c
index 735f5a3829..9ab537d8b9 100644
--- a/src/nvim/terminal.c
+++ b/src/nvim/terminal.c
@@ -1234,7 +1234,7 @@ static void refresh_screen(Terminal *term, buf_T *buf)
 
   int change_start = row_to_linenr(term, term->invalid_start);
   int change_end = change_start + changed;
-  // Note: don't send LiveUpdate event for a :terminal buffer
+  // Note: don't send nvim_buf_update event for a :terminal buffer
   changed_lines(change_start, 0, change_end, added, false);
   term->invalid_start = INT_MAX;
   term->invalid_end = -1;
diff --git a/src/nvim/undo.c b/src/nvim/undo.c
index 1c14e93211..9da9693c90 100644
--- a/src/nvim/undo.c
+++ b/src/nvim/undo.c
@@ -92,7 +92,7 @@
 #include "nvim/eval.h"
 #include "nvim/fileio.h"
 #include "nvim/fold.h"
-#include "nvim/liveupdate.h"
+#include "nvim/buffer_updates.h"
 #include "nvim/mark.h"
 #include "nvim/memline.h"
 #include "nvim/message.h"
@@ -1698,7 +1698,7 @@ bool u_undo_and_forget(int count)
     count = 1;
   }
   undo_undoes = true;
-  // don't send a LiveUpdate for this undo is part of 'inccommand' playing with
+  // don't send a nvim_buf_update for this undo is part of 'inccommand' playing with
   // buffer contents
   u_doit(count, true, false);
 
@@ -1735,7 +1735,7 @@ bool u_undo_and_forget(int count)
 }
 
 /// Undo or redo, depending on `undo_undoes`, `count` times.
-static void u_doit(int startcount, bool quiet, bool send_liveupdate)
+static void u_doit(int startcount, bool quiet, bool send_update)
 {
   int count = startcount;
 
@@ -1771,7 +1771,7 @@ static void u_doit(int startcount, bool quiet, bool send_liveupdate)
         break;
       }
 
-      u_undoredo(true, send_liveupdate);
+      u_undoredo(true, send_update);
     } else {
       if (curbuf->b_u_curhead == NULL || get_undolevel() <= 0) {
         beep_flush();           /* nothing to redo */
@@ -1782,7 +1782,7 @@ static void u_doit(int startcount, bool quiet, bool send_liveupdate)
         break;
       }
 
-      u_undoredo(false, send_liveupdate);
+      u_undoredo(false, send_update);
 
       /* Advance for next redo.  Set "newhead" when at the end of the
        * redoable changes. */
@@ -2117,7 +2117,7 @@ void undo_time(long step, int sec, int file, int absolute)
  *
  * When "undo" is TRUE we go up in the tree, when FALSE we go down.
  */
-static void u_undoredo(int undo, bool send_liveupdate)
+static void u_undoredo(int undo, bool send_update)
 {
   char_u      **newarray = NULL;
   linenr_T oldsize;
@@ -2245,7 +2245,7 @@ static void u_undoredo(int undo, bool send_liveupdate)
       }
     }
 
-    changed_lines(top + 1, 0, bot, newsize - oldsize, send_liveupdate);
+    changed_lines(top + 1, 0, bot, newsize - oldsize, send_update);
 
     /* set '[ and '] mark */
     if (top + 1 < curbuf->b_op_start.lnum)
@@ -2281,10 +2281,10 @@ static void u_undoredo(int undo, bool send_liveupdate)
   }
 
   // because the calls to changed()/unchanged() above will bump b_changedtick
-  // again, we need to send a LiveUpdate with just the new value of
+  // again, we need to send a nvim_buf_update with just the new value of
   // b:changedtick
-  if (send_liveupdate && kv_size(curbuf->liveupdate_channels)) {
-    liveupdate_send_tick(curbuf);
+  if (send_update && kv_size(curbuf->update_channels)) {
+    buffer_updates_send_tick(curbuf);
   }
 
   /*
diff --git a/test/functional/api/liveupdate_spec.lua b/test/functional/api/buffer_updates_spec.lua
similarity index 67%
rename from test/functional/api/liveupdate_spec.lua
rename to test/functional/api/buffer_updates_spec.lua
index e674913464..c3a1754cf3 100644
--- a/test/functional/api/liveupdate_spec.lua
+++ b/test/functional/api/buffer_updates_spec.lua
@@ -1,7 +1,7 @@
 local helpers = require('test.functional.helpers')(after_each)
 local eq, ok = helpers.eq, helpers.ok
 local buffer, command, eval, nvim, next_message = helpers.buffer,
-  helpers.command, helpers.eval, helpers.nvim, helpers.next_message
+  helpers.command, helpers.eval, helpers.nvim, helpers.next_msg
 
 local origlines = {"original line 1",
                    "original line 2",
@@ -32,11 +32,11 @@ local function open(activate, lines)
   -- what is the value of b:changedtick?
   local tick = eval('b:changedtick')
 
-  -- turn on live updates, ensure that the LiveUpdateStart messages
+  -- turn on live updates, ensure that the nvim_buf_updates_start messages
   -- arrive as expectected
   if activate then
-    ok(buffer('live_updates_start', b, true))
-    expectn('LiveUpdateStart', {b, tick, lines, false})
+    ok(buffer('attach', b, true))
+    expectn('nvim_buf_updates_start', {b, tick, lines, false})
   end
 
   return b, tick, filename
@@ -52,13 +52,13 @@ local function editoriginal(activate, lines)
 end
 
 local function reopen(buf, expectedlines)
-  ok(buffer('live_updates_stop', buf))
-  expectn('LiveUpdateEnd', {buf})
+  ok(buffer('detach', buf))
+  expectn('nvim_buf_updates_end', {buf})
   -- for some reason the :edit! increments tick by 2
   command('edit!')
   local tick = eval('b:changedtick')
-  ok(buffer('live_updates_start', buf, true))
-  expectn('LiveUpdateStart', {buf, tick, expectedlines, false})
+  ok(buffer('attach', buf, true))
+  expectn('nvim_buf_updates_start', {buf, tick, expectedlines, false})
   command('normal! gg')
   return tick
 end
@@ -73,13 +73,13 @@ local function reopenwithfolds(b)
   -- add a fold
   command('2,4fold')
   tick = tick + 1
-  expectn('LiveUpdate', {b, tick, 1, 4, {'original line 2/*{{{*/',
+  expectn('nvim_buf_update', {b, tick, 1, 4, {'original line 2/*{{{*/',
                                           'original line 3',
                                           'original line 4/*}}}*/'}})
   -- make a new fold that wraps lines 1-6
   command('1,6fold')
   tick = tick + 1
-  expectn('LiveUpdate', {b, tick, 0, 6, {'original line 1/*{{{*/',
+  expectn('nvim_buf_update', {b, tick, 0, 6, {'original line 1/*{{{*/',
                                           'original line 2/*{{{*/',
                                           'original line 3',
                                           'original line 4/*}}}*/',
@@ -95,30 +95,30 @@ describe('liveupdate', function()
     -- add a new line at the start of the buffer
     command('normal! GyyggP')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 0, 0, {'original line 6'}})
+    expectn('nvim_buf_update', {b, tick, 0, 0, {'original line 6'}})
 
     -- add multiple lines at the start of the file
     command('normal! GkkyGggP')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 0, 0, {'original line 4',
+    expectn('nvim_buf_update', {b, tick, 0, 0, {'original line 4',
                                            'original line 5',
                                            'original line 6'}})
 
     -- add one line to the middle of the file, several times
     command('normal! ggYjjp')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 3, 3, {'original line 4'}})
+    expectn('nvim_buf_update', {b, tick, 3, 3, {'original line 4'}})
     command('normal! p')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 4, 4, {'original line 4'}})
+    expectn('nvim_buf_update', {b, tick, 4, 4, {'original line 4'}})
     command('normal! p')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 5, 5, {'original line 4'}})
+    expectn('nvim_buf_update', {b, tick, 5, 5, {'original line 4'}})
 
     -- add multiple lines to the middle of the file
     command('normal! gg4Yjjp')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 3, 3, {'original line 4',
+    expectn('nvim_buf_update', {b, tick, 3, 3, {'original line 4',
                                            'original line 5',
                                            'original line 6',
                                            'original line 4'}})
@@ -126,16 +126,16 @@ describe('liveupdate', function()
     -- add one line to the end of the file
     command('normal! ggYGp')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 17, 17, {'original line 4'}})
+    expectn('nvim_buf_update', {b, tick, 17, 17, {'original line 4'}})
 
     -- add one line to the end of the file, several times
     command('normal! ggYGppp')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 18, 18, {'original line 4'}})
+    expectn('nvim_buf_update', {b, tick, 18, 18, {'original line 4'}})
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 19, 19, {'original line 4'}})
+    expectn('nvim_buf_update', {b, tick, 19, 19, {'original line 4'}})
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 20, 20, {'original line 4'}})
+    expectn('nvim_buf_update', {b, tick, 20, 20, {'original line 4'}})
 
     -- add several lines to the end of the file, several times
     command('normal! gg4YGp')
@@ -146,47 +146,47 @@ describe('liveupdate', function()
                  'original line 6',
                  'original line 4'}
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 21, 21, firstfour})
+    expectn('nvim_buf_update', {b, tick, 21, 21, firstfour})
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 25, 25, firstfour})
+    expectn('nvim_buf_update', {b, tick, 25, 25, firstfour})
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 29, 29, firstfour})
+    expectn('nvim_buf_update', {b, tick, 29, 29, firstfour})
 
     -- create a new empty buffer and wipe out the old one ... this will
     -- turn off live updates
     command('enew!')
-    expectn('LiveUpdateEnd', {b})
+    expectn('nvim_buf_updates_end', {b})
 
     -- add a line at the start of an empty file
     command('enew')
     tick = eval('b:changedtick')
     local b2 = nvim('get_current_buf')
-    ok(buffer('live_updates_start', b2, true))
-    expectn('LiveUpdateStart', {b2, tick, {""}, false})
+    ok(buffer('attach', b2, true))
+    expectn('nvim_buf_updates_start', {b2, tick, {""}, false})
     eval('append(0, ["new line 1"])')
     tick = tick + 1
-    expectn('LiveUpdate', {b2, tick, 0, 0, {'new line 1'}})
+    expectn('nvim_buf_update', {b2, tick, 0, 0, {'new line 1'}})
 
     -- turn off live updates manually
-    buffer('live_updates_stop', b2)
-    expectn('LiveUpdateEnd', {b2})
+    buffer('detach', b2)
+    expectn('nvim_buf_updates_end', {b2})
 
     -- add multiple lines to a blank file
     command('enew!')
     local b3 = nvim('get_current_buf')
-    ok(buffer('live_updates_start', b3, true))
+    ok(buffer('attach', b3, true))
     tick = eval('b:changedtick')
-    expectn('LiveUpdateStart', {b3, tick, {""}, false})
+    expectn('nvim_buf_updates_start', {b3, tick, {""}, false})
     eval('append(0, ["new line 1", "new line 2", "new line 3"])')
     tick = tick + 1
-    expectn('LiveUpdate', {b3, tick, 0, 0, {'new line 1',
+    expectn('nvim_buf_update', {b3, tick, 0, 0, {'new line 1',
                                             'new line 2',
                                             'new line 3'}})
 
     -- use the API itself to add a line to the start of the buffer
     buffer('set_lines', b3, 0, 0, true, {'New First Line'})
     tick = tick + 1
-    expectn('LiveUpdate', {b3, tick, 0, 0, {"New First Line"}})
+    expectn('nvim_buf_update', {b3, tick, 0, 0, {"New First Line"}})
   end)
 
   it('knows when you remove lines from a buffer', function()
@@ -195,37 +195,37 @@ describe('liveupdate', function()
     -- remove one line from start of file
     command('normal! dd')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 0, 1, {}})
+    expectn('nvim_buf_update', {b, tick, 0, 1, {}})
 
     -- remove multiple lines from the start of the file
     command('normal! 4dd')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 0, 4, {}})
+    expectn('nvim_buf_update', {b, tick, 0, 4, {}})
 
     -- remove multiple lines from middle of file
     tick = reopen(b, origlines)
     command('normal! jj3dd')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 2, 5, {}})
+    expectn('nvim_buf_update', {b, tick, 2, 5, {}})
 
     -- remove one line from the end of the file
     tick = reopen(b, origlines)
     command('normal! Gdd')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 5, 6, {}})
+    expectn('nvim_buf_update', {b, tick, 5, 6, {}})
 
     -- remove multiple lines from the end of the file
     tick = reopen(b, origlines)
     command('normal! 4G3dd')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 3, 6, {}})
+    expectn('nvim_buf_update', {b, tick, 3, 6, {}})
 
     -- pretend to remove heaps lines from the end of the file but really
     -- just remove two
     tick = reopen(b, origlines)
     command('normal! Gk5dd')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 4, 6, {}})
+    expectn('nvim_buf_update', {b, tick, 4, 6, {}})
   end)
 
   it('knows when you modify lines of text', function()
@@ -234,53 +234,53 @@ describe('liveupdate', function()
     -- some normal text editing
     command('normal! A555')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 0, 1, {'original line 1555'}})
+    expectn('nvim_buf_update', {b, tick, 0, 1, {'original line 1555'}})
     command('normal! jj8X')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 2, 3, {'origin3'}})
+    expectn('nvim_buf_update', {b, tick, 2, 3, {'origin3'}})
 
     -- modify multiple lines at once using visual block mode
     tick = reopen(b, origlines)
     command('normal! jjw')
     sendkeys('\x16jjllx')
     tick = tick + 1
-    expectn('LiveUpdate',
+    expectn('nvim_buf_update',
             {b, tick, 2, 5, {'original e 3', 'original e 4', 'original e 5'}})
 
     -- replace part of a line line using :s
     tick = reopen(b, origlines)
     command('3s/line 3/foo/')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 2, 3, {'original foo'}})
+    expectn('nvim_buf_update', {b, tick, 2, 3, {'original foo'}})
 
     -- replace parts of several lines line using :s
     tick = reopen(b, origlines)
     command('%s/line [35]/foo/')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 2, 5, {'original foo',
+    expectn('nvim_buf_update', {b, tick, 2, 5, {'original foo',
                                            'original line 4',
                                            'original foo'}})
 
     -- type text into the first line of a blank file, one character at a time
     command('enew!')
     tick = 2
-    expectn('LiveUpdateEnd', {b})
+    expectn('nvim_buf_updates_end', {b})
     local bnew = nvim('get_current_buf')
-    ok(buffer('live_updates_start', bnew, true))
-    expectn('LiveUpdateStart', {bnew, tick, {''}, false})
+    ok(buffer('attach', bnew, true))
+    expectn('nvim_buf_updates_start', {bnew, tick, {''}, false})
     sendkeys('i')
     sendkeys('h')
     sendkeys('e')
     sendkeys('l')
     sendkeys('l')
     sendkeys('o\nworld')
-    expectn('LiveUpdate', {bnew, tick + 1, 0, 1, {'h'}})
-    expectn('LiveUpdate', {bnew, tick + 2, 0, 1, {'he'}})
-    expectn('LiveUpdate', {bnew, tick + 3, 0, 1, {'hel'}})
-    expectn('LiveUpdate', {bnew, tick + 4, 0, 1, {'hell'}})
-    expectn('LiveUpdate', {bnew, tick + 5, 0, 1, {'hello'}})
-    expectn('LiveUpdate', {bnew, tick + 6, 0, 1, {'hello', ''}})
-    expectn('LiveUpdate', {bnew, tick + 7, 1, 2, {'world'}})
+    expectn('nvim_buf_update', {bnew, tick + 1, 0, 1, {'h'}})
+    expectn('nvim_buf_update', {bnew, tick + 2, 0, 1, {'he'}})
+    expectn('nvim_buf_update', {bnew, tick + 3, 0, 1, {'hel'}})
+    expectn('nvim_buf_update', {bnew, tick + 4, 0, 1, {'hell'}})
+    expectn('nvim_buf_update', {bnew, tick + 5, 0, 1, {'hello'}})
+    expectn('nvim_buf_update', {bnew, tick + 6, 0, 1, {'hello', ''}})
+    expectn('nvim_buf_update', {bnew, tick + 7, 1, 2, {'world'}})
   end)
 
   it('knows when you replace lines', function()
@@ -289,23 +289,23 @@ describe('liveupdate', function()
     -- blast away parts of some lines with visual mode
     command('normal! jjwvjjllx')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 2, 3, {'original '}})
+    expectn('nvim_buf_update', {b, tick, 2, 3, {'original '}})
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 3, 4, {}})
+    expectn('nvim_buf_update', {b, tick, 3, 4, {}})
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 3, 4, {'e 5'}})
+    expectn('nvim_buf_update', {b, tick, 3, 4, {'e 5'}})
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 2, 3, {'original e 5'}})
+    expectn('nvim_buf_update', {b, tick, 2, 3, {'original e 5'}})
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 3, 4, {}})
+    expectn('nvim_buf_update', {b, tick, 3, 4, {}})
 
     -- blast away a few lines using :g
     tick = reopen(b, origlines)
     command('global/line [35]/delete')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 2, 3, {}})
+    expectn('nvim_buf_update', {b, tick, 2, 3, {}})
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 3, 4, {}})
+    expectn('nvim_buf_update', {b, tick, 3, 4, {}})
   end)
 
   it('knows when you filter lines', function()
@@ -317,9 +317,9 @@ describe('liveupdate', function()
     -- 1) addition of the new lines after the filtered lines
     -- 2) removal of the original lines
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 5, 5, {"C", "E", "B", "D"}})
+    expectn('nvim_buf_update', {b, tick, 5, 5, {"C", "E", "B", "D"}})
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 1, 5, {}})
+    expectn('nvim_buf_update', {b, tick, 1, 5, {}})
   end)
 
   it('sends a sensible event when you use "o"', function()
@@ -329,37 +329,37 @@ describe('liveupdate', function()
     -- use 'o' to start a new line from a line with no indent
     command('normal! o')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 1, 1, {""}})
+    expectn('nvim_buf_update', {b, tick, 1, 1, {""}})
 
     -- undo the change, indent line 1 a bit, and try again
     command('undo')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 1, 2, {}})
+    expectn('nvim_buf_update', {b, tick, 1, 2, {}})
     tick = tick + 1
-    expectn('LiveUpdateTick', {b, tick})
+    expectn('nvim_buf_update_tick', {b, tick})
     command('set autoindent')
     command('normal! >>')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 0, 1, {"\tAAA"}})
+    expectn('nvim_buf_update', {b, tick, 0, 1, {"\tAAA"}})
     command('normal! ommm')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 1, 1, {"\t"}})
+    expectn('nvim_buf_update', {b, tick, 1, 1, {"\t"}})
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 1, 2, {"\tmmm"}})
+    expectn('nvim_buf_update', {b, tick, 1, 2, {"\tmmm"}})
 
     -- undo the change, and try again with 'O'
     command('undo')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 1, 2, {'\t'}})
+    expectn('nvim_buf_update', {b, tick, 1, 2, {'\t'}})
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 1, 2, {}})
+    expectn('nvim_buf_update', {b, tick, 1, 2, {}})
     tick = tick + 1
-    expectn('LiveUpdateTick', {b, tick})
+    expectn('nvim_buf_update_tick', {b, tick})
     command('normal! ggOmmm')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 0, 0, {"\t"}})
+    expectn('nvim_buf_update', {b, tick, 0, 0, {"\t"}})
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 0, 1, {"\tmmm"}})
+    expectn('nvim_buf_update', {b, tick, 0, 1, {"\tmmm"}})
   end)
 
   it('deactivates when your buffer changes outside vim', function()
@@ -369,12 +369,12 @@ describe('liveupdate', function()
 
     command('normal! x')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 0, 1, {'ine 1'}})
+    expectn('nvim_buf_update', {b, tick, 0, 1, {'ine 1'}})
     command('undo')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 0, 1, {'Line 1'}})
+    expectn('nvim_buf_update', {b, tick, 0, 1, {'Line 1'}})
     tick = tick + 1
-    expectn('LiveUpdateTick', {b, tick})
+    expectn('nvim_buf_update_tick', {b, tick})
 
     -- change the file directly
     local f = io.open(filename, 'a')
@@ -384,7 +384,7 @@ describe('liveupdate', function()
 
     -- reopen the file and watch live updates shut down
     command('edit')
-    expectn('LiveUpdateEnd', {b})
+    expectn('nvim_buf_updates_end', {b})
   end)
 
   it('allows a channel to watch multiple buffers at once', function()
@@ -405,32 +405,32 @@ describe('liveupdate', function()
     command('b'..b1nr)
     command('normal! x')
     tick1 = tick1 + 1
-    expectn('LiveUpdate', {b1, tick1, 0, 1, {'1'}})
+    expectn('nvim_buf_update', {b1, tick1, 0, 1, {'1'}})
     command('undo')
     tick1 = tick1 + 1
-    expectn('LiveUpdate', {b1, tick1, 0, 1, {'A1'}})
+    expectn('nvim_buf_update', {b1, tick1, 0, 1, {'A1'}})
     tick1 = tick1 + 1
-    expectn('LiveUpdateTick', {b1, tick1})
+    expectn('nvim_buf_update_tick', {b1, tick1})
 
     command('b'..b2nr)
     command('normal! x')
     tick2 = tick2 + 1
-    expectn('LiveUpdate', {b2, tick2, 0, 1, {'1'}})
+    expectn('nvim_buf_update', {b2, tick2, 0, 1, {'1'}})
     command('undo')
     tick2 = tick2 + 1
-    expectn('LiveUpdate', {b2, tick2, 0, 1, {'B1'}})
+    expectn('nvim_buf_update', {b2, tick2, 0, 1, {'B1'}})
     tick2 = tick2 + 1
-    expectn('LiveUpdateTick', {b2, tick2})
+    expectn('nvim_buf_update_tick', {b2, tick2})
 
     command('b'..b3nr)
     command('normal! x')
     tick3 = tick3 + 1
-    expectn('LiveUpdate', {b3, tick3, 0, 1, {'1'}})
+    expectn('nvim_buf_update', {b3, tick3, 0, 1, {'1'}})
     command('undo')
     tick3 = tick3 + 1
-    expectn('LiveUpdate', {b3, tick3, 0, 1, {'C1'}})
+    expectn('nvim_buf_update', {b3, tick3, 0, 1, {'C1'}})
     tick3 = tick3 + 1
-    expectn('LiveUpdateTick', {b3, tick3})
+    expectn('nvim_buf_update_tick', {b3, tick3})
   end)
 
   it('doesn\'t get confused when you turn watching on/off many times',
@@ -439,22 +439,22 @@ describe('liveupdate', function()
     local b, tick = editoriginal(false)
 
     -- turn on live updates many times
-    ok(buffer('live_updates_start', b, true))
-    ok(buffer('live_updates_start', b, true))
-    ok(buffer('live_updates_start', b, true))
-    ok(buffer('live_updates_start', b, true))
-    ok(buffer('live_updates_start', b, true))
-    expectn('LiveUpdateStart', {b, tick, origlines, false})
+    ok(buffer('attach', b, true))
+    ok(buffer('attach', b, true))
+    ok(buffer('attach', b, true))
+    ok(buffer('attach', b, true))
+    ok(buffer('attach', b, true))
+    expectn('nvim_buf_updates_start', {b, tick, origlines, false})
     eval('rpcnotify('..channel..', "Hello There")')
     expectn('Hello There', {})
 
     -- turn live updates off many times
-    ok(buffer('live_updates_stop', b))
-    ok(buffer('live_updates_stop', b))
-    ok(buffer('live_updates_stop', b))
-    ok(buffer('live_updates_stop', b))
-    ok(buffer('live_updates_stop', b))
-    expectn('LiveUpdateEnd', {b})
+    ok(buffer('detach', b))
+    ok(buffer('detach', b))
+    ok(buffer('detach', b))
+    ok(buffer('detach', b))
+    ok(buffer('detach', b))
+    expectn('nvim_buf_updates_end', {b})
     eval('rpcnotify('..channel..', "Hello Again")')
     expectn('Hello Again', {})
   end)
@@ -488,46 +488,46 @@ describe('liveupdate', function()
     local b, tick = open(false, lines)
 
     -- turn on live updates for sessions 1, 2 and 3
-    ok(request(1, 'nvim_buf_live_updates_start', b, true))
-    ok(request(2, 'nvim_buf_live_updates_start', b, true))
-    ok(request(3, 'nvim_buf_live_updates_start', b, true))
-    wantn(1, 'LiveUpdateStart', {b, tick, lines, false})
-    wantn(2, 'LiveUpdateStart', {b, tick, lines, false})
-    wantn(3, 'LiveUpdateStart', {b, tick, lines, false})
+    ok(request(1, 'nvim_buf_attach', b, true))
+    ok(request(2, 'nvim_buf_attach', b, true))
+    ok(request(3, 'nvim_buf_attach', b, true))
+    wantn(1, 'nvim_buf_updates_start', {b, tick, lines, false})
+    wantn(2, 'nvim_buf_updates_start', {b, tick, lines, false})
+    wantn(3, 'nvim_buf_updates_start', {b, tick, lines, false})
 
     -- make a change to the buffer
     command('normal! x')
     tick = tick + 1
-    wantn(1, 'LiveUpdate', {b, tick, 0, 1, {'AA'}})
-    wantn(2, 'LiveUpdate', {b, tick, 0, 1, {'AA'}})
-    wantn(3, 'LiveUpdate', {b, tick, 0, 1, {'AA'}})
+    wantn(1, 'nvim_buf_update', {b, tick, 0, 1, {'AA'}})
+    wantn(2, 'nvim_buf_update', {b, tick, 0, 1, {'AA'}})
+    wantn(3, 'nvim_buf_update', {b, tick, 0, 1, {'AA'}})
 
     -- stop watching on channel 1
-    ok(request(1, 'nvim_buf_live_updates_stop', b))
-    wantn(1, 'LiveUpdateEnd', {b})
+    ok(request(1, 'nvim_buf_detach', b))
+    wantn(1, 'nvim_buf_updates_end', {b})
 
     -- undo the change to buffer 1
     command('undo')
     tick = tick + 1
-    wantn(2, 'LiveUpdate', {b, tick, 0, 1, {'AAA'}})
-    wantn(3, 'LiveUpdate', {b, tick, 0, 1, {'AAA'}})
+    wantn(2, 'nvim_buf_update', {b, tick, 0, 1, {'AAA'}})
+    wantn(3, 'nvim_buf_update', {b, tick, 0, 1, {'AAA'}})
     tick = tick + 1
-    wantn(2, 'LiveUpdateTick', {b, tick})
-    wantn(3, 'LiveUpdateTick', {b, tick})
+    wantn(2, 'nvim_buf_update_tick', {b, tick})
+    wantn(3, 'nvim_buf_update_tick', {b, tick})
 
-    -- make sure there are no other pending LiveUpdate messages going to
+    -- make sure there are no other pending nvim_buf_update messages going to
     -- channel 1
     local channel1 = request(1, 'nvim_get_api_info')[1]
     eval('rpcnotify('..channel1..', "Hello")')
     wantn(1, 'Hello', {})
 
-    -- close the buffer and channels 2 and 3 should get a LiveUpdateEnd
+    -- close the buffer and channels 2 and 3 should get a nvim_buf_updates_end
     -- notification
     command('edit')
-    wantn(2, 'LiveUpdateEnd', {b})
-    wantn(3, 'LiveUpdateEnd', {b})
+    wantn(2, 'nvim_buf_updates_end', {b})
+    wantn(3, 'nvim_buf_updates_end', {b})
 
-    -- make sure there are no other pending LiveUpdate messages going to
+    -- make sure there are no other pending nvim_buf_update messages going to
     -- channel 1
     channel1 = request(1, 'nvim_get_api_info')[1]
     eval('rpcnotify('..channel1..', "Hello Again")')
@@ -550,13 +550,13 @@ describe('liveupdate', function()
     command('normal! gg')
     command('diffput')
     tick2 = tick2 + 1
-    expectn('LiveUpdate', {b2, tick2, 0, 0, {"AAA"}})
+    expectn('nvim_buf_update', {b2, tick2, 0, 0, {"AAA"}})
 
     -- use :diffget to grab the other change from buffer 2
     command('normal! G')
     command('diffget')
     tick1 = tick1 + 1
-    expectn('LiveUpdate', {b1, tick1, 2, 2, {"CCC"}})
+    expectn('nvim_buf_update', {b1, tick1, 2, 2, {"CCC"}})
 
     eval('rpcnotify('..channel..', "Goodbye")')
     expectn('Goodbye', {})
@@ -567,14 +567,14 @@ describe('liveupdate', function()
     local b, tick = editoriginal(true, {"B", "D", "C", "A", "E"})
     command('%sort')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 0, 5, {"A", "B", "C", "D", "E"}})
+    expectn('nvim_buf_update', {b, tick, 0, 5, {"A", "B", "C", "D", "E"}})
   end)
 
   it('works with :left', function()
     local b, tick = editoriginal(true, {" A", "  B", "B", "\tB", "\t\tC"})
     command('2,4left')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 1, 4, {"B", "B", "B"}})
+    expectn('nvim_buf_update', {b, tick, 1, 4, {"B", "B", "B"}})
   end)
 
   it('works with :right', function()
@@ -586,7 +586,7 @@ describe('liveupdate', function()
     command('set ts=2 et')
     command('2,4retab')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 1, 4, {"    B", "      BB", "  B"}})
+    expectn('nvim_buf_update', {b, tick, 1, 4, {"    B", "      BB", "  B"}})
   end)
 
   it('works with :move', function()
@@ -594,19 +594,19 @@ describe('liveupdate', function()
     -- move text down towards the end of the file
     command('2,3move 4')
     tick = tick + 2
-    expectn('LiveUpdate', {b, tick, 4, 4, {"original line 2",
+    expectn('nvim_buf_update', {b, tick, 4, 4, {"original line 2",
                                            "original line 3"}})
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 1, 3, {}})
+    expectn('nvim_buf_update', {b, tick, 1, 3, {}})
 
     -- move text up towards the start of the file
     tick = reopen(b, origlines)
     command('4,5move 2')
     tick = tick + 2
-    expectn('LiveUpdate', {b, tick, 2, 2, {"original line 4",
+    expectn('nvim_buf_update', {b, tick, 2, 2, {"original line 4",
                                            "original line 5"}})
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 5, 7, {}})
+    expectn('nvim_buf_update', {b, tick, 5, 7, {}})
   end)
 
   it('sends sensible events when you manually add/remove folds', function()
@@ -616,13 +616,13 @@ describe('liveupdate', function()
     -- delete the inner fold
     command('normal! zR3Gzd')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 1, 4, {'original line 2',
+    expectn('nvim_buf_update', {b, tick, 1, 4, {'original line 2',
                                            'original line 3',
                                            'original line 4'}})
     -- delete the outer fold
     command('normal! zd')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 0, 6, origlines})
+    expectn('nvim_buf_update', {b, tick, 0, 6, origlines})
 
     -- discard changes and put the folds back
     tick = reopenwithfolds(b)
@@ -630,7 +630,7 @@ describe('liveupdate', function()
     -- remove both folds at once
     command('normal! ggzczD')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 0, 6, origlines})
+    expectn('nvim_buf_update', {b, tick, 0, 6, origlines})
 
     -- discard changes and put the folds back
     tick = reopenwithfolds(b)
@@ -638,17 +638,17 @@ describe('liveupdate', function()
     -- now delete all folds at once
     command('normal! zE')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 0, 6, origlines})
+    expectn('nvim_buf_update', {b, tick, 0, 6, origlines})
 
     -- create a fold from line 4 to the end of the file
     command('normal! 4GA/*{{{*/')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 3, 4, {'original line 4/*{{{*/'}})
+    expectn('nvim_buf_update', {b, tick, 3, 4, {'original line 4/*{{{*/'}})
 
     -- delete the fold which only has one marker
     command('normal! Gzd')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 3, 6, {'original line 4',
+    expectn('nvim_buf_update', {b, tick, 3, 6, {'original line 4',
                                            'original line 5',
                                            'original line 6'}})
   end)
@@ -660,16 +660,16 @@ describe('liveupdate', function()
     -- test live updates are working
     command('normal! x')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 0, 1, {'AA'}})
+    expectn('nvim_buf_update', {b, tick, 0, 1, {'AA'}})
     command('undo')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 0, 1, {'AAA'}})
+    expectn('nvim_buf_update', {b, tick, 0, 1, {'AAA'}})
     tick = tick + 1
-    expectn('LiveUpdateTick', {b, tick})
+    expectn('nvim_buf_update_tick', {b, tick})
 
     -- close our buffer by creating a new one
     command('enew')
-    expectn('LiveUpdateEnd', {b})
+    expectn('nvim_buf_updates_end', {b})
 
     -- reopen the original buffer, make sure there are no Live Updates sent
     command('b1')
@@ -687,18 +687,18 @@ describe('liveupdate', function()
     -- test live updates are working
     command('normal! x')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 0, 1, {'AA'}})
+    expectn('nvim_buf_update', {b, tick, 0, 1, {'AA'}})
     command('undo')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 0, 1, {'AAA'}})
+    expectn('nvim_buf_update', {b, tick, 0, 1, {'AAA'}})
     tick = tick + 1
-    expectn('LiveUpdateTick', {b, tick})
+    expectn('nvim_buf_update_tick', {b, tick})
 
     -- close our buffer by creating a new one
     command('set hidden')
     command('enew')
 
-    -- note that no LiveUpdateEnd is sent
+    -- note that no nvim_buf_updates_end is sent
     eval('rpcnotify('..channel..', "Hello There")')
     expectn('Hello There', {})
 
@@ -706,7 +706,7 @@ describe('liveupdate', function()
     command('b1')
     command('normal! x')
     tick = tick + 1
-    expectn('LiveUpdate', {b, tick, 0, 1, {'AA'}})
+    expectn('nvim_buf_update', {b, tick, 0, 1, {'AA'}})
   end)
 
   it('turns off live updates when a buffer is unloaded, deleted, or wiped',
@@ -721,17 +721,17 @@ describe('liveupdate', function()
       local b = open(true, {'AAA'})
 
       -- call :bunload or whatever the command is, and then check that we
-      -- receive a LiveUpdateEnd
+      -- receive a nvim_buf_updates_end
       command(cmd)
-      expectn('LiveUpdateEnd', {b})
+      expectn('nvim_buf_updates_end', {b})
     end
   end)
 
   it('doesn\'t send the buffer\'s content when not requested', function()
     helpers.clear()
     local b, tick = editoriginal(false)
-    ok(buffer('live_updates_start', b, false))
-    expectn('LiveUpdateStart', {b, tick, {}, false})
+    ok(buffer('attach', b, false))
+    expectn('nvim_buf_updates_start', {b, tick, {}, false})
   end)
 
 end)

From 2106bada5bbd6de4729a8714d011e0eca61cee35 Mon Sep 17 00:00:00 2001
From: KillTheMule <KillTheMule@users.noreply.github.com>
Date: Sun, 11 Feb 2018 23:02:53 +0100
Subject: [PATCH 15/26] Enable -Wconversion

---
 src/nvim/CMakeLists.txt   |  1 -
 src/nvim/api/buffer.c     | 10 +++++-----
 src/nvim/buffer_updates.c | 22 +++++++++++++++++-----
 src/nvim/buffer_updates.h | 11 +++++++----
 src/nvim/ex_cmds.c        |  2 +-
 src/nvim/fold.c           |  6 +++---
 src/nvim/misc1.c          |  6 +++---
 src/nvim/undo.c           |  4 ++--
 8 files changed, 38 insertions(+), 24 deletions(-)

diff --git a/src/nvim/CMakeLists.txt b/src/nvim/CMakeLists.txt
index 97495eec6d..2d803792c8 100644
--- a/src/nvim/CMakeLists.txt
+++ b/src/nvim/CMakeLists.txt
@@ -142,7 +142,6 @@ set(CONV_SOURCES
   message.c
   regexp.c
   screen.c
-  buffer_updates.c
   search.c
   spell.c
   spellfile.c
diff --git a/src/nvim/api/buffer.c b/src/nvim/api/buffer.c
index d59ce1ce3d..f6a6534560 100644
--- a/src/nvim/api/buffer.c
+++ b/src/nvim/api/buffer.c
@@ -85,9 +85,9 @@ String buffer_get_line(Buffer buffer, Integer index, Error *err)
 /// @return False when updates couldn't be enabled because the buffer isn't
 ///         loaded; otherwise True.
 Boolean nvim_buf_attach(uint64_t channel_id,
-                                 Buffer buffer,
-                                 Boolean send_buffer,
-                                 Error *err)
+                        Buffer buffer,
+                        Boolean send_buffer,
+                        Error *err)
   FUNC_API_SINCE(4) FUNC_API_REMOTE_ONLY
 {
   buf_T *buf = find_buffer_by_handle(buffer, err);
@@ -106,8 +106,8 @@ Boolean nvim_buf_attach(uint64_t channel_id,
 /// @return False when updates couldn't be disabled because the buffer
 ///         isn't loaded; otherwise True.
 Boolean nvim_buf_detach(uint64_t channel_id,
-                                 Buffer buffer,
-                                 Error *err)
+                        Buffer buffer,
+                        Error *err)
   FUNC_API_SINCE(4) FUNC_API_REMOTE_ONLY
 {
   buf_T *buf = find_buffer_by_handle(buffer, err);
diff --git a/src/nvim/buffer_updates.c b/src/nvim/buffer_updates.c
index d7bb11d125..3d0c969491 100644
--- a/src/nvim/buffer_updates.c
+++ b/src/nvim/buffer_updates.c
@@ -2,6 +2,7 @@
 #include "nvim/memline.h"
 #include "nvim/api/private/helpers.h"
 #include "nvim/msgpack_rpc/channel.h"
+#include "nvim/assert.h"
 
 // Register a channel. Return True if the channel was added, or already added.
 // Return False if the channel couldn't be added because the buffer is
@@ -30,7 +31,10 @@ bool buffer_updates_register(buf_T *buf, uint64_t channel_id, bool send_buffer)
   Array linedata = ARRAY_DICT_INIT;
   if (send_buffer) {
     // collect buffer contents
-    size_t line_count = buf->b_ml.ml_line_count;
+    // True now, but a compile time reminder for future systems we support
+    STATIC_ASSERT(SIZE_MAX >= MAXLNUM, "size_t to small to hold the number of"
+                  " lines in a buffer");
+    size_t line_count = (size_t)buf->b_ml.ml_line_count;
     linedata.size = line_count;
     linedata.items = xcalloc(sizeof(Object), line_count);
     for (size_t i = 0; i < line_count; i++) {
@@ -118,8 +122,11 @@ void buffer_updates_unregister_all(buf_T *buf)
   }
 }
 
-void buffer_updates_send_changes(buf_T *buf, linenr_T firstline, int64_t num_added,
-                             int64_t num_removed, bool send_tick)
+void buffer_updates_send_changes(buf_T *buf,
+                                 linenr_T firstline,
+                                 int64_t num_added,
+                                 int64_t num_removed,
+                                 bool send_tick)
 {
   // if one the channels doesn't work, put its ID here so we can remove it later
   uint64_t badchannelid = 0;
@@ -148,8 +155,13 @@ void buffer_updates_send_changes(buf_T *buf, linenr_T firstline, int64_t num_add
     // linedata of lines being swapped in
     Array linedata = ARRAY_DICT_INIT;
     if (num_added > 0) {
-        linedata.size = num_added;
-        linedata.items = xcalloc(sizeof(Object), num_added);
+        // True now, but a compile time reminder for future systems we support
+        // Note that `num_added` is a `int64_t`, but still must be lower than
+        // `MAX_LNUM`
+        STATIC_ASSERT(SIZE_MAX >= MAXLNUM, "size_t to small to hold the number "
+                      "of lines in a buffer");
+        linedata.size = (size_t)num_added;
+        linedata.items = xcalloc(sizeof(Object), (size_t)num_added);
         for (int64_t i = 0; i < num_added; i++) {
           int64_t lnum = firstline + i;
           const char *bufstr = (char *)ml_get_buf(buf, (linenr_T)lnum, false);
diff --git a/src/nvim/buffer_updates.h b/src/nvim/buffer_updates.h
index 8fe33a0ebe..63ae2d3984 100644
--- a/src/nvim/buffer_updates.h
+++ b/src/nvim/buffer_updates.h
@@ -1,13 +1,16 @@
-#ifndef BUFFER_UPDATES_H
-#define BUFFER_UPDATES_H
+#ifndef NVIM_BUFFER_UPDATES_H
+#define NVIM_BUFFER_UPDATES_H
 
 #include "nvim/buffer_defs.h"
 
 bool buffer_updates_register(buf_T *buf, uint64_t channel_id, bool send_buffer);
 void buffer_updates_unregister(buf_T *buf, uint64_t channel_id);
 void buffer_updates_unregister_all(buf_T *buf);
-void buffer_updates_send_changes(buf_T *buf, linenr_T firstline, int64_t num_added,
-                             int64_t num_removed, bool send_tick);
+void buffer_updates_send_changes(buf_T *buf,
+                                 linenr_T firstline,
+                                 int64_t num_added,
+                                 int64_t num_removed,
+                                 bool send_tick);
 void buffer_updates_send_tick(buf_T *buf);
 
 #endif  // NVIM_BUFFER_UPDATES_H
diff --git a/src/nvim/ex_cmds.c b/src/nvim/ex_cmds.c
index fdb8c87213..3960412782 100644
--- a/src/nvim/ex_cmds.c
+++ b/src/nvim/ex_cmds.c
@@ -4022,7 +4022,7 @@ skip:
       int64_t num_added = last_line - first_line;
       int64_t num_removed = num_added - i;
       buffer_updates_send_changes(curbuf, first_line, num_added, num_removed,
-                              send_buffer_update_changedtick);
+                                  send_buffer_update_changedtick);
     }
   }
 
diff --git a/src/nvim/fold.c b/src/nvim/fold.c
index 2cf1c6f394..9869e0fd30 100644
--- a/src/nvim/fold.c
+++ b/src/nvim/fold.c
@@ -754,7 +754,7 @@ deleteFold (
       // notification that includes every line that was part of the fold
       int64_t num_changed = last_lnum - first_lnum;
       buffer_updates_send_changes(curbuf, first_lnum, num_changed,
-                              num_changed, true);
+                                  num_changed, true);
     }
   }
 }
@@ -1607,8 +1607,8 @@ static void foldCreateMarkers(linenr_T start, linenr_T end)
 
   if (kv_size(curbuf->update_channels)) {
     // Note: foldAddMarker() may not actually change start and/or end if
-    // u_save() is unable to save the buffer line, but we send the nvim_buf_update
-    // anyway since it won't do any harm.
+    // u_save() is unable to save the buffer line, but we send the
+    // nvim_buf_update anyway since it won't do any harm.
     int64_t num_changed = 1 + end - start;
     buffer_updates_send_changes(curbuf, start, num_changed, num_changed, true);
   }
diff --git a/src/nvim/misc1.c b/src/nvim/misc1.c
index 7c9e728c92..47ec3eff32 100644
--- a/src/nvim/misc1.c
+++ b/src/nvim/misc1.c
@@ -1921,9 +1921,9 @@ changed_lines(
     linenr_T lnume,       // line below last changed line
     long xtra,            // number of extra lines (negative when deleting)
     bool send_update  // some callers like undo/redo call changed_lines()
-                          // and then increment b_changedtick *again*. This flag
-                          // allows these callers to send the nvim_buf_update events
-                          // after they're done modifying b_changedtick.
+                      // and then increment b_changedtick *again*. This flag
+                      // allows these callers to send the nvim_buf_update events
+                      // after they're done modifying b_changedtick.
 )
 {
   changed_lines_buf(curbuf, lnum, lnume, xtra);
diff --git a/src/nvim/undo.c b/src/nvim/undo.c
index 9da9693c90..ed4515398d 100644
--- a/src/nvim/undo.c
+++ b/src/nvim/undo.c
@@ -1698,8 +1698,8 @@ bool u_undo_and_forget(int count)
     count = 1;
   }
   undo_undoes = true;
-  // don't send a nvim_buf_update for this undo is part of 'inccommand' playing with
-  // buffer contents
+  // don't send a nvim_buf_update for this undo is part of 'inccommand' playing
+  // with buffer contents
   u_doit(count, true, false);
 
   if (curbuf->b_u_curhead == NULL) {

From 5aa8af7cdb5a2a8ed2cef02e6d7a0b9a2c714140 Mon Sep 17 00:00:00 2001
From: KillTheMule <KillTheMule@users.noreply.github.com>
Date: Mon, 12 Feb 2018 21:41:21 +0100
Subject: [PATCH 16/26] Increase sendkeys timeout

---
 test/functional/api/buffer_updates_spec.lua | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/functional/api/buffer_updates_spec.lua b/test/functional/api/buffer_updates_spec.lua
index c3a1754cf3..cb20184a50 100644
--- a/test/functional/api/buffer_updates_spec.lua
+++ b/test/functional/api/buffer_updates_spec.lua
@@ -20,7 +20,7 @@ local function sendkeys(keys)
   -- give neovim some time to process msgpack requests before possibly sending
   -- more key presses - otherwise they all pile up in the queue and get
   -- processed at once
-  local ntime = os.clock() + 0.01
+  local ntime = os.clock() + 0.1
   repeat until os.clock() > ntime
 end
 

From de5d1e863c71c8da87422bdb94dc91749d4a8b61 Mon Sep 17 00:00:00 2001
From: KillTheMule <KillTheMule@users.noreply.github.com>
Date: Mon, 12 Feb 2018 22:49:35 +0100
Subject: [PATCH 17/26] Try fixing that test on travis

---
 runtime/doc/msgpack_rpc.txt                 | 42 ++++++---------------
 test/functional/api/buffer_updates_spec.lua |  2 +-
 2 files changed, 12 insertions(+), 32 deletions(-)

diff --git a/runtime/doc/msgpack_rpc.txt b/runtime/doc/msgpack_rpc.txt
index bf7c63710f..0b0e774d33 100644
--- a/runtime/doc/msgpack_rpc.txt
+++ b/runtime/doc/msgpack_rpc.txt
@@ -242,32 +242,12 @@ the type codes, because a client may be built against one Nvim version but
 connect to another with different type codes.
 
 ==============================================================================
-6. Buffer Updates				      *buffer-updates* *rpc-buffer-updates*
+6. Buffer Updates				                *buffer-updates* *rpc-buffer-updates*
 
 A dedicated API has been created to allow co-processes to be notified  when a
 buffer is changed in any way. It is difficult and error-prone to try and do
 this with autocommands such as |TextChanged|.
 
-                                                              *buffer-updates-api*
-BufferUpdates Functions~
-
-nvim_buf_attach({send_buffer})                                *nvim_buf_attach()*
-              Register a plugin to receive notifications on buffer changes. An
-              initial |nvim_buf_updates_start| notification will be sent as a
-              confirmation. After that, |nvim_buf_update| notifications will be
-              sent for buffer updates, and |nvim_buf_update_tick| notifications
-              for a new changedtick without buffer change.
-
-              Parameters:~
-                  {send_buffer}  Bool. If `"True"`, the initial
-                  |nvim_buf_updates_start| notification will also send the full
-                  buffer's content. If `"False"`, the notification will contain
-                  an empty list instead.
-
-nvim_buf_detach()                                            *nvim_buf_detach()*
-              Unregister a plugin from buffer change notifications. A final
-              |nvim_buf_updates_end| notification will be sent as confirmation.
-
                                                            *buffer-updates-events*
 BufferUpdates Events~
 
@@ -372,41 +352,41 @@ the buffer contents are unloaded from memory:
   - reloading the buffer after it is changed from outside neovim.
 
                                                        *buffer-updates-examples*
-Example Events~
+Examples~
 
-If buffer updates are activated a new empty buffer, the following
+If buffer updates are activated a new empty buffer (and sending the buffer's
+content on the initial notification has been requested), the following
 |nvim_buf_updates_start| event will be sent: >
 
-  rpcnotify({channel}, "nvim_buf_updates_start", [{buf}, [""], v:false])
+  nvim_buf_updates_start[{buf}, [""], v:false]
 
 If the user adds 2 new lines to the start of a buffer, the following event
 would be generated: >
 
-  rpcnotify({channel}, "nvim_buf_update", [{buf}, 0, 0, ["line1", "line2"]])
+  nvim_buf_update[{buf}, 0, 0, ["line1", "line2"]]
 
 If the puts the cursor on a line containing the text `"Hello world"` and adds
 a `!` character to the end using insert mode, the following event would be
 generated: >
 
-  rpcnotify({channel}, "nvim_buf_update", [{buf}, {linenr}, {linenr} + 1, ["Hello
-  world!"]])
+  nvim_buf_update[{buf}, {linenr}, {linenr} + 1, ["Hello world!"]]
 
 If the user moves their cursor to line 3 of a buffer and deletes 20 lines
 using `20dd`, the following event will be generated: >
 
-  rpcnotify({channel}, "nvim_buf_update", [{buf}, 2, 20, []])
+  nvim_buf_update[{buf}, 2, 20, []]
 
 If the user selects lines 3-5 of a buffer using |linewise-visual| mode and
 then presses `p` to paste in a new block of 6 lines, then the following event
 would be sent to the co-process: >
 
-  rpcnotify({channel}, "nvim_buf_update", [{buf}, 2, 5, ['pasted line 1', 'pasted
+  nvim_buf_update[{buf}, 2, 5, ['pasted line 1', 'pasted
   line 2', 'pasted line 3', 'pasted line 4', 'pasted line 5', 'pasted line
-  6']])
+  6']]
 
 If the user uses :edit to reload a buffer then the following event would be
 generated: >
 
-  rpcnotify({channel}, "nvim_buf_updates_end", [{buf}])
+  nvim_buf_updates_end[{buf}]
 
  vim:tw=78:ts=8:ft=help:norl:
diff --git a/test/functional/api/buffer_updates_spec.lua b/test/functional/api/buffer_updates_spec.lua
index cb20184a50..b30d0805bd 100644
--- a/test/functional/api/buffer_updates_spec.lua
+++ b/test/functional/api/buffer_updates_spec.lua
@@ -242,7 +242,7 @@ describe('liveupdate', function()
     -- modify multiple lines at once using visual block mode
     tick = reopen(b, origlines)
     command('normal! jjw')
-    sendkeys('\x16jjllx')
+    sendkeys('<C-v>jjllx')
     tick = tick + 1
     expectn('nvim_buf_update',
             {b, tick, 2, 5, {'original e 3', 'original e 4', 'original e 5'}})

From e7451f8a91e0a9452fc3c3627ac60dc80288252c Mon Sep 17 00:00:00 2001
From: KillTheMule <KillTheMule@users.noreply.github.com>
Date: Tue, 24 Apr 2018 20:38:00 +0200
Subject: [PATCH 18/26] Some renamings and doc changes

---
 runtime/doc/msgpack_rpc.txt                 | 22 ++++++-------
 src/nvim/api/buffer.c                       |  4 +--
 src/nvim/buffer.c                           |  4 +--
 src/nvim/buffer_updates.c                   | 20 ++++++------
 src/nvim/buffer_updates.h                   | 10 +++---
 src/nvim/ex_cmds.c                          | 13 ++++----
 src/nvim/fold.c                             |  4 +--
 src/nvim/misc1.c                            |  8 ++---
 src/nvim/undo.c                             | 35 +++++++++++----------
 test/functional/api/buffer_updates_spec.lua | 20 ++++++------
 10 files changed, 72 insertions(+), 68 deletions(-)

diff --git a/runtime/doc/msgpack_rpc.txt b/runtime/doc/msgpack_rpc.txt
index 0b0e774d33..9ebebb8d61 100644
--- a/runtime/doc/msgpack_rpc.txt
+++ b/runtime/doc/msgpack_rpc.txt
@@ -255,16 +255,16 @@ The co-process will start receiving the following notification events:
 
 nvim_buf_updates_start[{buf}, {changedtick}, {linedata}, {more}]	 *nvim_buf_updates_start*
 
-  Neovim will send at least one of these notifications to confirm that
-  buffer updates are registered for this plugin, and possibly send the buffer's
-  contents. If the buffer is very large, neovim might send the contents through
-  in multiple events to avoid loading the entire buffer's contents into
-  memory at once.
+  Nvim will send at least one of these notifications to confirm that buffer
+  updates are registered for this plugin, and possibly send the buffer's
+  contents. If the buffer is very large, nvim might send the contents
+  through in multiple events to avoid loading the entire buffer's contents
+  into memory at once.
 
 	{buf} is an API handle for the buffer.
 
 	{changedtick} is the value of |b:changedtick| for the buffer. If you
-	send an API command back to neovim you can check the value of
+	send an API command back to nvim you can check the value of
 	|b:changedtick| as part of your request to ensure that no other
 	changes have been made. 
 
@@ -279,9 +279,9 @@ nvim_buf_updates_start[{buf}, {changedtick}, {linedata}, {more}]	 *nvim_buf_upda
   will be empty.
 
   {linedata} will always have at least 1 item, but the maximum length is
-  determined by neovim and not guaranteed to be any particular size.  Also the
+  determined by nvim and not guaranteed to be any particular size.  Also the
   number of {linedata} items may vary between notifications, so your plugin
-  must be prepared to receive the line data in whatever size lists neovim
+  must be prepared to receive the line data in whatever size lists nvim
   decides to split it into.
 
   {more} is a boolean which tells you whether or not to expect more
@@ -298,7 +298,7 @@ nvim_buf_update[{buf}, {changedtick}, {firstline}, {lastline}, {linedata}] *nvim
 	{buf} is an API handle for the buffer.
 
   {changedtick} is the value of |b:changedtick| for the buffer. If you send an
-  API command back to neovim you can check the value of |b:changedtick| as
+  API command back to nvim you can check the value of |b:changedtick| as
   part of your request to ensure that no other changes have been made.
 
   {firstline} is the integer line number of the first line that was replaced.
@@ -324,7 +324,7 @@ nvim_buf_update[{buf}, {changedtick}, {firstline}, {lastline}, {linedata}] *nvim
   doesn't reflect the actual buffer contents. Currently this behaviour is
   only used for the 'inccommand' option.
 
-nvim_buf_update_tick[{buf}, {changedtick}]		                   *nvim_buf_update_tick*
+nvim_buf_changedtick[{buf}, {changedtick}]		                   *nvim_buf_changedtick*
 
   Indicates that |b:changedtick| was incremented for the buffer {buf}, but no
   text was changed. This is currently only used by undo/redo.
@@ -349,7 +349,7 @@ the buffer contents are unloaded from memory:
 
   - Closing all a buffer's windows (unless 'hidden' is enabled).
   - Using |:edit| to reload the buffer
-  - reloading the buffer after it is changed from outside neovim.
+  - reloading the buffer after it is changed from outside nvim.
 
                                                        *buffer-updates-examples*
 Examples~
diff --git a/src/nvim/api/buffer.c b/src/nvim/api/buffer.c
index f6a6534560..756367f801 100644
--- a/src/nvim/api/buffer.c
+++ b/src/nvim/api/buffer.c
@@ -96,7 +96,7 @@ Boolean nvim_buf_attach(uint64_t channel_id,
     return false;
   }
 
-  return buffer_updates_register(buf, channel_id, send_buffer);
+  return buf_updates_register(buf, channel_id, send_buffer);
 }
 //
 /// Deactivate updates from this buffer to the current channel.
@@ -116,7 +116,7 @@ Boolean nvim_buf_detach(uint64_t channel_id,
     return false;
   }
 
-  buffer_updates_unregister(buf, channel_id);
+  buf_updates_unregister(buf, channel_id);
   return true;
 }
 
diff --git a/src/nvim/buffer.c b/src/nvim/buffer.c
index e5b7128248..af77a9891b 100644
--- a/src/nvim/buffer.c
+++ b/src/nvim/buffer.c
@@ -576,7 +576,7 @@ void close_buffer(win_T *win, buf_T *buf, int action, int abort_if_last)
   do_autochdir();
 
   // disable live updates for the current buffer
-  buffer_updates_unregister_all(buf);
+  buf_updates_unregister_all(buf);
 
   /*
    * Remove the buffer from the list.
@@ -789,7 +789,7 @@ free_buffer_stuff (
   xfree(buf->b_start_fenc);
   buf->b_start_fenc = NULL;
 
-  buffer_updates_unregister_all(buf);
+  buf_updates_unregister_all(buf);
 }
 
 /*
diff --git a/src/nvim/buffer_updates.c b/src/nvim/buffer_updates.c
index 3d0c969491..830c1bfe7b 100644
--- a/src/nvim/buffer_updates.c
+++ b/src/nvim/buffer_updates.c
@@ -7,7 +7,7 @@
 // Register a channel. Return True if the channel was added, or already added.
 // Return False if the channel couldn't be added because the buffer is
 // unloaded.
-bool buffer_updates_register(buf_T *buf, uint64_t channel_id, bool send_buffer)
+bool buf_updates_register(buf_T *buf, uint64_t channel_id, bool send_buffer)
 {
   // must fail if the buffer isn't loaded
   if (buf->b_ml.ml_mfp == NULL) {
@@ -64,7 +64,7 @@ bool buffer_updates_register(buf_T *buf, uint64_t channel_id, bool send_buffer)
   return true;
 }
 
-void buffer_updates_send_end(buf_T *buf, uint64_t channelid)
+void buf_updates_send_end(buf_T *buf, uint64_t channelid)
 {
     Array args = ARRAY_DICT_INIT;
     args.size = 1;
@@ -73,7 +73,7 @@ void buffer_updates_send_end(buf_T *buf, uint64_t channelid)
     rpc_send_event(channelid, "nvim_buf_updates_end", args);
 }
 
-void buffer_updates_unregister(buf_T *buf, uint64_t channelid)
+void buf_updates_unregister(buf_T *buf, uint64_t channelid)
 {
   size_t size = kv_size(buf->update_channels);
   if (!size) {
@@ -101,7 +101,7 @@ void buffer_updates_unregister(buf_T *buf, uint64_t channelid)
     buf->update_channels.size -= found;
 
     // make a new copy of the active array without the channelid in it
-    buffer_updates_send_end(buf, channelid);
+    buf_updates_send_end(buf, channelid);
 
     if (found == size) {
       kv_destroy(buf->update_channels);
@@ -110,19 +110,19 @@ void buffer_updates_unregister(buf_T *buf, uint64_t channelid)
   }
 }
 
-void buffer_updates_unregister_all(buf_T *buf)
+void buf_updates_unregister_all(buf_T *buf)
 {
   size_t size = kv_size(buf->update_channels);
   if (size) {
     for (size_t i = 0; i < size; i++) {
-      buffer_updates_send_end(buf, kv_A(buf->update_channels, i));
+      buf_updates_send_end(buf, kv_A(buf->update_channels, i));
     }
     kv_destroy(buf->update_channels);
     kv_init(buf->update_channels);
   }
 }
 
-void buffer_updates_send_changes(buf_T *buf,
+void buf_updates_send_changes(buf_T *buf,
                                  linenr_T firstline,
                                  int64_t num_added,
                                  int64_t num_removed,
@@ -187,11 +187,11 @@ void buffer_updates_send_changes(buf_T *buf,
   // cleared up quickly.
   if (badchannelid != 0) {
     ELOG("Disabling live updates for dead channel %llu", badchannelid);
-    buffer_updates_unregister(buf, badchannelid);
+    buf_updates_unregister(buf, badchannelid);
   }
 }
 
-void buffer_updates_send_tick(buf_T *buf)
+void buf_updates_changedtick(buf_T *buf)
 {
   // notify each of the active channels
   for (size_t i = 0; i < kv_size(buf->update_channels); i++) {
@@ -209,6 +209,6 @@ void buffer_updates_send_tick(buf_T *buf)
     args.items[1] = INTEGER_OBJ(buf->b_changedtick);
 
     // don't try and clean up dead channels here
-    rpc_send_event(channelid, "nvim_buf_update_tick", args);
+    rpc_send_event(channelid, "nvim_buf_changedtick", args);
   }
 }
diff --git a/src/nvim/buffer_updates.h b/src/nvim/buffer_updates.h
index 63ae2d3984..23804809f1 100644
--- a/src/nvim/buffer_updates.h
+++ b/src/nvim/buffer_updates.h
@@ -3,14 +3,14 @@
 
 #include "nvim/buffer_defs.h"
 
-bool buffer_updates_register(buf_T *buf, uint64_t channel_id, bool send_buffer);
-void buffer_updates_unregister(buf_T *buf, uint64_t channel_id);
-void buffer_updates_unregister_all(buf_T *buf);
-void buffer_updates_send_changes(buf_T *buf,
+bool buf_updates_register(buf_T *buf, uint64_t channel_id, bool send_buffer);
+void buf_updates_unregister(buf_T *buf, uint64_t channel_id);
+void buf_updates_unregister_all(buf_T *buf);
+void buf_updates_send_changes(buf_T *buf,
                                  linenr_T firstline,
                                  int64_t num_added,
                                  int64_t num_removed,
                                  bool send_tick);
-void buffer_updates_send_tick(buf_T *buf);
+void buf_updates_changedtick(buf_T *buf);
 
 #endif  // NVIM_BUFFER_UPDATES_H
diff --git a/src/nvim/ex_cmds.c b/src/nvim/ex_cmds.c
index 3960412782..e342ae44aa 100644
--- a/src/nvim/ex_cmds.c
+++ b/src/nvim/ex_cmds.c
@@ -835,7 +835,7 @@ int do_move(linenr_T line1, linenr_T line2, linenr_T dest)
 
   // send update regarding the new lines that were added
   if (kv_size(curbuf->update_channels)) {
-    buffer_updates_send_changes(curbuf, dest + 1, num_lines, 0, true);
+    buf_updates_send_changes(curbuf, dest + 1, num_lines, 0, true);
   }
 
   /*
@@ -874,7 +874,7 @@ int do_move(linenr_T line1, linenr_T line2, linenr_T dest)
 
   // send nvim_buf_update regarding lines that were deleted
   if (kv_size(curbuf->update_channels)) {
-    buffer_updates_send_changes(curbuf, line1 + extra, 0, num_lines, true);
+    buf_updates_send_changes(curbuf, line1 + extra, 0, num_lines, true);
   }
 
   return OK;
@@ -2442,7 +2442,7 @@ int do_ecmd(
         goto theend;
       }
       u_unchanged(curbuf);
-      buffer_updates_unregister_all(curbuf);
+      buf_updates_unregister_all(curbuf);
       buf_freeall(curbuf, BFA_KEEP_UNDO);
 
       // Tell readfile() not to clear or reload undo info.
@@ -3168,9 +3168,10 @@ static char_u *sub_parse_flags(char_u *cmd, subflags_T *subflags,
 ///
 /// The usual escapes are supported as described in the regexp docs.
 ///
+/// @param do_buf_event If `true`, send buffer updates.
 /// @return buffer used for 'inccommand' preview
 static buf_T *do_sub(exarg_T *eap, proftime_T timeout,
-                     bool send_buffer_update_changedtick)
+                     bool do_buf_event)
 {
   long i = 0;
   regmmatch_T regmatch;
@@ -4021,8 +4022,8 @@ skip:
     if (kv_size(curbuf->update_channels)) {
       int64_t num_added = last_line - first_line;
       int64_t num_removed = num_added - i;
-      buffer_updates_send_changes(curbuf, first_line, num_added, num_removed,
-                                  send_buffer_update_changedtick);
+      buf_updates_send_changes(curbuf, first_line, num_added, num_removed,
+                                  do_buf_event);
     }
   }
 
diff --git a/src/nvim/fold.c b/src/nvim/fold.c
index 9869e0fd30..4d947d9b07 100644
--- a/src/nvim/fold.c
+++ b/src/nvim/fold.c
@@ -753,7 +753,7 @@ deleteFold (
       // the modification of the *first* line of the fold, but we send through a
       // notification that includes every line that was part of the fold
       int64_t num_changed = last_lnum - first_lnum;
-      buffer_updates_send_changes(curbuf, first_lnum, num_changed,
+      buf_updates_send_changes(curbuf, first_lnum, num_changed,
                                   num_changed, true);
     }
   }
@@ -1610,7 +1610,7 @@ static void foldCreateMarkers(linenr_T start, linenr_T end)
     // u_save() is unable to save the buffer line, but we send the
     // nvim_buf_update anyway since it won't do any harm.
     int64_t num_changed = 1 + end - start;
-    buffer_updates_send_changes(curbuf, start, num_changed, num_changed, true);
+    buf_updates_send_changes(curbuf, start, num_changed, num_changed, true);
   }
 }
 
diff --git a/src/nvim/misc1.c b/src/nvim/misc1.c
index 47ec3eff32..de68031135 100644
--- a/src/nvim/misc1.c
+++ b/src/nvim/misc1.c
@@ -1823,7 +1823,7 @@ void changed_bytes(linenr_T lnum, colnr_T col)
   changed_common(lnum, col, lnum + 1, 0L);
   // notify any channels that are watching
   if (kv_size(curbuf->update_channels)) {
-    buffer_updates_send_changes(curbuf, lnum, 1, 1, true);
+    buf_updates_send_changes(curbuf, lnum, 1, 1, true);
   }
 
   /* Diff highlighting in other diff windows may need to be updated too. */
@@ -1920,7 +1920,7 @@ changed_lines(
     colnr_T col,          // column in first line with change
     linenr_T lnume,       // line below last changed line
     long xtra,            // number of extra lines (negative when deleting)
-    bool send_update  // some callers like undo/redo call changed_lines()
+    bool do_buf_event  // some callers like undo/redo call changed_lines()
                       // and then increment b_changedtick *again*. This flag
                       // allows these callers to send the nvim_buf_update events
                       // after they're done modifying b_changedtick.
@@ -1948,10 +1948,10 @@ changed_lines(
 
   changed_common(lnum, col, lnume, xtra);
 
-  if (send_update && kv_size(curbuf->update_channels)) {
+  if (do_buf_event && kv_size(curbuf->update_channels)) {
     int64_t num_added = (int64_t)(lnume + xtra - lnum);
     int64_t num_removed = lnume - lnum;
-    buffer_updates_send_changes(curbuf, lnum, num_added, num_removed, true);
+    buf_updates_send_changes(curbuf, lnum, num_added, num_removed, true);
   }
 }
 
diff --git a/src/nvim/undo.c b/src/nvim/undo.c
index ed4515398d..985c6873a4 100644
--- a/src/nvim/undo.c
+++ b/src/nvim/undo.c
@@ -1735,7 +1735,11 @@ bool u_undo_and_forget(int count)
 }
 
 /// Undo or redo, depending on `undo_undoes`, `count` times.
-static void u_doit(int startcount, bool quiet, bool send_update)
+///
+/// @param startcount How often to undo or redo
+/// @param quiet If `true`, don't show messages
+/// @param do_buf_event If `true`, send the changedtick with the buffer updates
+static void u_doit(int startcount, bool quiet, bool do_buf_event)
 {
   int count = startcount;
 
@@ -1771,7 +1775,7 @@ static void u_doit(int startcount, bool quiet, bool send_update)
         break;
       }
 
-      u_undoredo(true, send_update);
+      u_undoredo(true, do_buf_event);
     } else {
       if (curbuf->b_u_curhead == NULL || get_undolevel() <= 0) {
         beep_flush();           /* nothing to redo */
@@ -1782,7 +1786,7 @@ static void u_doit(int startcount, bool quiet, bool send_update)
         break;
       }
 
-      u_undoredo(false, send_update);
+      u_undoredo(false, do_buf_event);
 
       /* Advance for next redo.  Set "newhead" when at the end of the
        * redoable changes. */
@@ -2108,16 +2112,15 @@ void undo_time(long step, int sec, int file, int absolute)
   u_undo_end(did_undo, absolute, false);
 }
 
-/*
- * u_undoredo: common code for undo and redo
- *
- * The lines in the file are replaced by the lines in the entry list at
- * curbuf->b_u_curhead. The replaced lines in the file are saved in the entry
- * list for the next undo/redo.
- *
- * When "undo" is TRUE we go up in the tree, when FALSE we go down.
- */
-static void u_undoredo(int undo, bool send_update)
+/// u_undoredo: common code for undo and redo
+///
+/// The lines in the file are replaced by the lines in the entry list at
+/// curbuf->b_u_curhead. The replaced lines in the file are saved in the entry
+/// list for the next undo/redo.
+///
+/// @param undo If `true`, go up the tree. Down if `false`.
+/// @param do_buf_event If `true`, send buffer updates.
+static void u_undoredo(int undo, bool do_buf_event)
 {
   char_u      **newarray = NULL;
   linenr_T oldsize;
@@ -2245,7 +2248,7 @@ static void u_undoredo(int undo, bool send_update)
       }
     }
 
-    changed_lines(top + 1, 0, bot, newsize - oldsize, send_update);
+    changed_lines(top + 1, 0, bot, newsize - oldsize, do_buf_event);
 
     /* set '[ and '] mark */
     if (top + 1 < curbuf->b_op_start.lnum)
@@ -2283,8 +2286,8 @@ static void u_undoredo(int undo, bool send_update)
   // because the calls to changed()/unchanged() above will bump b_changedtick
   // again, we need to send a nvim_buf_update with just the new value of
   // b:changedtick
-  if (send_update && kv_size(curbuf->update_channels)) {
-    buffer_updates_send_tick(curbuf);
+  if (do_buf_event && kv_size(curbuf->update_channels)) {
+    buf_updates_changedtick(curbuf);
   }
 
   /*
diff --git a/test/functional/api/buffer_updates_spec.lua b/test/functional/api/buffer_updates_spec.lua
index b30d0805bd..7659961e90 100644
--- a/test/functional/api/buffer_updates_spec.lua
+++ b/test/functional/api/buffer_updates_spec.lua
@@ -336,7 +336,7 @@ describe('liveupdate', function()
     tick = tick + 1
     expectn('nvim_buf_update', {b, tick, 1, 2, {}})
     tick = tick + 1
-    expectn('nvim_buf_update_tick', {b, tick})
+    expectn('nvim_buf_changedtick', {b, tick})
     command('set autoindent')
     command('normal! >>')
     tick = tick + 1
@@ -354,7 +354,7 @@ describe('liveupdate', function()
     tick = tick + 1
     expectn('nvim_buf_update', {b, tick, 1, 2, {}})
     tick = tick + 1
-    expectn('nvim_buf_update_tick', {b, tick})
+    expectn('nvim_buf_changedtick', {b, tick})
     command('normal! ggOmmm')
     tick = tick + 1
     expectn('nvim_buf_update', {b, tick, 0, 0, {"\t"}})
@@ -374,7 +374,7 @@ describe('liveupdate', function()
     tick = tick + 1
     expectn('nvim_buf_update', {b, tick, 0, 1, {'Line 1'}})
     tick = tick + 1
-    expectn('nvim_buf_update_tick', {b, tick})
+    expectn('nvim_buf_changedtick', {b, tick})
 
     -- change the file directly
     local f = io.open(filename, 'a')
@@ -410,7 +410,7 @@ describe('liveupdate', function()
     tick1 = tick1 + 1
     expectn('nvim_buf_update', {b1, tick1, 0, 1, {'A1'}})
     tick1 = tick1 + 1
-    expectn('nvim_buf_update_tick', {b1, tick1})
+    expectn('nvim_buf_changedtick', {b1, tick1})
 
     command('b'..b2nr)
     command('normal! x')
@@ -420,7 +420,7 @@ describe('liveupdate', function()
     tick2 = tick2 + 1
     expectn('nvim_buf_update', {b2, tick2, 0, 1, {'B1'}})
     tick2 = tick2 + 1
-    expectn('nvim_buf_update_tick', {b2, tick2})
+    expectn('nvim_buf_changedtick', {b2, tick2})
 
     command('b'..b3nr)
     command('normal! x')
@@ -430,7 +430,7 @@ describe('liveupdate', function()
     tick3 = tick3 + 1
     expectn('nvim_buf_update', {b3, tick3, 0, 1, {'C1'}})
     tick3 = tick3 + 1
-    expectn('nvim_buf_update_tick', {b3, tick3})
+    expectn('nvim_buf_changedtick', {b3, tick3})
   end)
 
   it('doesn\'t get confused when you turn watching on/off many times',
@@ -512,8 +512,8 @@ describe('liveupdate', function()
     wantn(2, 'nvim_buf_update', {b, tick, 0, 1, {'AAA'}})
     wantn(3, 'nvim_buf_update', {b, tick, 0, 1, {'AAA'}})
     tick = tick + 1
-    wantn(2, 'nvim_buf_update_tick', {b, tick})
-    wantn(3, 'nvim_buf_update_tick', {b, tick})
+    wantn(2, 'nvim_buf_changedtick', {b, tick})
+    wantn(3, 'nvim_buf_changedtick', {b, tick})
 
     -- make sure there are no other pending nvim_buf_update messages going to
     -- channel 1
@@ -665,7 +665,7 @@ describe('liveupdate', function()
     tick = tick + 1
     expectn('nvim_buf_update', {b, tick, 0, 1, {'AAA'}})
     tick = tick + 1
-    expectn('nvim_buf_update_tick', {b, tick})
+    expectn('nvim_buf_changedtick', {b, tick})
 
     -- close our buffer by creating a new one
     command('enew')
@@ -692,7 +692,7 @@ describe('liveupdate', function()
     tick = tick + 1
     expectn('nvim_buf_update', {b, tick, 0, 1, {'AAA'}})
     tick = tick + 1
-    expectn('nvim_buf_update_tick', {b, tick})
+    expectn('nvim_buf_changedtick', {b, tick})
 
     -- close our buffer by creating a new one
     command('set hidden')

From 3866137eed6b6e649ac95e53ad246e977f9ac2ae Mon Sep 17 00:00:00 2001
From: KillTheMule <KillTheMule@users.noreply.github.com>
Date: Tue, 24 Apr 2018 21:41:59 +0200
Subject: [PATCH 19/26] Update test

---
 test/functional/api/buffer_updates_spec.lua | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/test/functional/api/buffer_updates_spec.lua b/test/functional/api/buffer_updates_spec.lua
index 7659961e90..0eec59bd65 100644
--- a/test/functional/api/buffer_updates_spec.lua
+++ b/test/functional/api/buffer_updates_spec.lua
@@ -1,6 +1,6 @@
 local helpers = require('test.functional.helpers')(after_each)
 local eq, ok = helpers.eq, helpers.ok
-local buffer, command, eval, nvim, next_message = helpers.buffer,
+local buffer, command, eval, nvim, next_msg = helpers.buffer,
   helpers.command, helpers.eval, helpers.nvim, helpers.next_msg
 
 local origlines = {"original line 1",
@@ -12,7 +12,7 @@ local origlines = {"original line 1",
 
 local function expectn(name, args)
   -- expect the next message to be the specified notification event
-  eq({'notification', name, args}, next_message())
+  eq({'notification', name, args}, next_msg())
 end
 
 local function sendkeys(keys)
@@ -88,8 +88,8 @@ local function reopenwithfolds(b)
   return tick
 end
 
-describe('liveupdate', function()
-  it('knows when you add line to a buffer', function()
+describe('buffer events', function()
+  it('when you add line to a buffer', function()
     local b, tick = editoriginal(true)
 
     -- add a new line at the start of the buffer

From 491efc89d2e8da319077f7c6d93f07a01b543ab0 Mon Sep 17 00:00:00 2001
From: KillTheMule <KillTheMule@users.noreply.github.com>
Date: Tue, 24 Apr 2018 21:45:36 +0200
Subject: [PATCH 20/26] Lint

---
 src/nvim/buffer_updates.c | 8 ++++----
 src/nvim/buffer_updates.h | 8 ++++----
 src/nvim/ex_cmds.c        | 2 +-
 src/nvim/fold.c           | 2 +-
 4 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/nvim/buffer_updates.c b/src/nvim/buffer_updates.c
index 830c1bfe7b..8eac695efe 100644
--- a/src/nvim/buffer_updates.c
+++ b/src/nvim/buffer_updates.c
@@ -123,10 +123,10 @@ void buf_updates_unregister_all(buf_T *buf)
 }
 
 void buf_updates_send_changes(buf_T *buf,
-                                 linenr_T firstline,
-                                 int64_t num_added,
-                                 int64_t num_removed,
-                                 bool send_tick)
+                              linenr_T firstline,
+                              int64_t num_added,
+                              int64_t num_removed,
+                              bool send_tick)
 {
   // if one the channels doesn't work, put its ID here so we can remove it later
   uint64_t badchannelid = 0;
diff --git a/src/nvim/buffer_updates.h b/src/nvim/buffer_updates.h
index 23804809f1..d052b8effb 100644
--- a/src/nvim/buffer_updates.h
+++ b/src/nvim/buffer_updates.h
@@ -7,10 +7,10 @@ bool buf_updates_register(buf_T *buf, uint64_t channel_id, bool send_buffer);
 void buf_updates_unregister(buf_T *buf, uint64_t channel_id);
 void buf_updates_unregister_all(buf_T *buf);
 void buf_updates_send_changes(buf_T *buf,
-                                 linenr_T firstline,
-                                 int64_t num_added,
-                                 int64_t num_removed,
-                                 bool send_tick);
+                              linenr_T firstline,
+                              int64_t num_added,
+                              int64_t num_removed,
+                              bool send_tick);
 void buf_updates_changedtick(buf_T *buf);
 
 #endif  // NVIM_BUFFER_UPDATES_H
diff --git a/src/nvim/ex_cmds.c b/src/nvim/ex_cmds.c
index e342ae44aa..0638c10dc0 100644
--- a/src/nvim/ex_cmds.c
+++ b/src/nvim/ex_cmds.c
@@ -4023,7 +4023,7 @@ skip:
       int64_t num_added = last_line - first_line;
       int64_t num_removed = num_added - i;
       buf_updates_send_changes(curbuf, first_line, num_added, num_removed,
-                                  do_buf_event);
+                               do_buf_event);
     }
   }
 
diff --git a/src/nvim/fold.c b/src/nvim/fold.c
index 4d947d9b07..32ba665f64 100644
--- a/src/nvim/fold.c
+++ b/src/nvim/fold.c
@@ -754,7 +754,7 @@ deleteFold (
       // notification that includes every line that was part of the fold
       int64_t num_changed = last_lnum - first_lnum;
       buf_updates_send_changes(curbuf, first_lnum, num_changed,
-                                  num_changed, true);
+                               num_changed, true);
     }
   }
 }

From 8ef3fb4e738c4021a1c779252a1dac53e09324fc Mon Sep 17 00:00:00 2001
From: KillTheMule <KillTheMule@users.noreply.github.com>
Date: Thu, 10 May 2018 14:25:59 +0200
Subject: [PATCH 21/26] Use autogenerated declarations

---
 src/nvim/buffer_updates.h | 12 +++---------
 1 file changed, 3 insertions(+), 9 deletions(-)

diff --git a/src/nvim/buffer_updates.h b/src/nvim/buffer_updates.h
index d052b8effb..b2d0a62270 100644
--- a/src/nvim/buffer_updates.h
+++ b/src/nvim/buffer_updates.h
@@ -3,14 +3,8 @@
 
 #include "nvim/buffer_defs.h"
 
-bool buf_updates_register(buf_T *buf, uint64_t channel_id, bool send_buffer);
-void buf_updates_unregister(buf_T *buf, uint64_t channel_id);
-void buf_updates_unregister_all(buf_T *buf);
-void buf_updates_send_changes(buf_T *buf,
-                              linenr_T firstline,
-                              int64_t num_added,
-                              int64_t num_removed,
-                              bool send_tick);
-void buf_updates_changedtick(buf_T *buf);
+#ifdef INCLUDE_GENERATED_DECLARATIONS
+# include "buffer_updates.h.generated.h"
+#endif
 
 #endif  // NVIM_BUFFER_UPDATES_H

From ad151847f179e51d70cbde9440e765c2a451a7f6 Mon Sep 17 00:00:00 2001
From: KillTheMule <KillTheMule@users.noreply.github.com>
Date: Thu, 10 May 2018 15:47:00 +0200
Subject: [PATCH 22/26] Unify updates_start and updates to lines_event

Also rename changedtick -> changedtick_event
---
 runtime/doc/msgpack_rpc.txt                 |  94 +++-----
 src/nvim/buffer_updates.c                   |  68 +++---
 test/functional/api/buffer_updates_spec.lua | 224 ++++++++++----------
 3 files changed, 186 insertions(+), 200 deletions(-)

diff --git a/runtime/doc/msgpack_rpc.txt b/runtime/doc/msgpack_rpc.txt
index 9ebebb8d61..571a08930c 100644
--- a/runtime/doc/msgpack_rpc.txt
+++ b/runtime/doc/msgpack_rpc.txt
@@ -242,7 +242,7 @@ the type codes, because a client may be built against one Nvim version but
 connect to another with different type codes.
 
 ==============================================================================
-6. Buffer Updates				                *buffer-updates* *rpc-buffer-updates*
+6. Buffer Updates				   *buffer-updates* *rpc-buffer-updates*
 
 A dedicated API has been created to allow co-processes to be notified  when a
 buffer is changed in any way. It is difficult and error-prone to try and do
@@ -253,94 +253,66 @@ BufferUpdates Events~
 
 The co-process will start receiving the following notification events:
 
-nvim_buf_updates_start[{buf}, {changedtick}, {linedata}, {more}]	 *nvim_buf_updates_start*
-
-  Nvim will send at least one of these notifications to confirm that buffer
-  updates are registered for this plugin, and possibly send the buffer's
-  contents. If the buffer is very large, nvim might send the contents
-  through in multiple events to avoid loading the entire buffer's contents
-  into memory at once.
-
-	{buf} is an API handle for the buffer.
-
-	{changedtick} is the value of |b:changedtick| for the buffer. If you
-	send an API command back to nvim you can check the value of
-	|b:changedtick| as part of your request to ensure that no other
-	changes have been made. 
-
-  {linedata} is a list of strings containing the buffer's contents. If this
-  list contains 100 strings, then they represent lines 1-100 of the buffer.
-  Newline characters are not included in the strings, so empty lines will be
-  given as empty strings. If you receive another |nvim_buf_updates_start|
-  notification with another {linedata} list, then these lines represent the
-  next N lines of the buffer. I.e., a second notification with another list of
-  100 strings will represent lines 101-200 of the buffer. If you send the
-  |nvim_buf_updates_start| request with its argument set to `"False"`, this
-  will be empty.
-
-  {linedata} will always have at least 1 item, but the maximum length is
-  determined by nvim and not guaranteed to be any particular size.  Also the
-  number of {linedata} items may vary between notifications, so your plugin
-  must be prepared to receive the line data in whatever size lists nvim
-  decides to split it into.
-
-  {more} is a boolean which tells you whether or not to expect more
-  |nvim_buf_updates_start| notifications. When {more} is false, you can be certain
-  that you now have the entire buffer's contents.
-
-nvim_buf_update[{buf}, {changedtick}, {firstline}, {lastline}, {linedata}] *nvim_buf_update*
+                                                                   *nvim_buf_lines_event*
+nvim_buf_lines_event[{buf}, {changedtick}, {firstline}, {lastline}, {linedata}, {more}]
 
   Indicates that the lines between {firstline} and {lastline} (end-exclusive,
   zero-indexed) have been replaced with the new line data contained in the
   {linedata} list.  All buffer changes (even adding single characters) will be
   transmitted as whole-line changes.
 
-	{buf} is an API handle for the buffer.
+    {buf} is an API handle for the buffer.
 
-  {changedtick} is the value of |b:changedtick| for the buffer. If you send an
-  API command back to nvim you can check the value of |b:changedtick| as
-  part of your request to ensure that no other changes have been made.
+    {changedtick} is the value of |b:changedtick| for the buffer. If you send an
+    API command back to nvim you can check the value of |b:changedtick| as
+    part of your request to ensure that no other changes have been made.
 
-  {firstline} is the integer line number of the first line that was replaced.
-  Note that {firstline} is zero-indexed, so if line `1` was replaced then
-  {firstline} will be `0` instead of `1`. {firstline} is guaranteed to always
-  be less than or equal to the number of lines that were in the buffer before
-  the lines were replaced.
+    {firstline} is the integer line number of the first line that was replaced.
+    Note that {firstline} is zero-indexed, so if line `1` was replaced then
+    {firstline} will be `0` instead of `1`. {firstline} is guaranteed to always
+    be less than or equal to the number of lines that were in the buffer before
+    the lines were replaced.
 
-  {lastline} is the integer line number of the first line that was not replaced
-  (i.e. the range {firstline}, {lastline} is end-exclusive). Note that
-  {lastline} is zero-indexed, so if line numbers 2 to 5 were replaced, this
-  will be `5` instead of `6`. {lastline} is guaranteed to always be less than
-  or equal to the number of lines that were in the buffer before the lines were
-  replaced.
+    {lastline} is the integer line number of the first line that was not replaced
+    (i.e. the range {firstline}, {lastline} is end-exclusive). Note that
+    {lastline} is zero-indexed, so if line numbers 2 to 5 were replaced, this
+    will be `5` instead of `6`. {lastline} is guaranteed to always be less than
+    or equal to the number of lines that were in the buffer before the lines were
+    replaced. {lastline} will be `-1` if the event is part of the initial
+    sending of the buffer.
 
-  {linedata} is a list of strings containing the contents of the new buffer
-  lines. Newline characters are not included in the strings, so empty lines
-  will be given as empty strings. 
+    {linedata} is a list of strings containing the contents of the new buffer
+    lines. Newline characters are not included in the strings, so empty lines
+    will be given as empty strings. 
+
+    {more} is a boolean which tells you whether or not to expect more
+    |nvim_buf_updates| notifications for a single buffer change (i.e. Nvim has
+    chunked up one event into several). Not yet used.
 
   Note: sometimes {changedtick} will be |v:null|, which means that the buffer
   text *looks* like it has changed, but actually hasn't. In this case the lines
   in {linedata} contain the modified text that is shown to the user, but
   doesn't reflect the actual buffer contents. Currently this behaviour is
-  only used for the 'inccommand' option.
+  only used for the |inccommand| option.
 
-nvim_buf_changedtick[{buf}, {changedtick}]		                   *nvim_buf_changedtick*
+nvim_buf_changedtick_event[{buf}, {changedtick}]	 *nvim_buf_changedtick*
 
   Indicates that |b:changedtick| was incremented for the buffer {buf}, but no
   text was changed. This is currently only used by undo/redo.
 
-  {buf} is an API handle for the buffer.
+    {buf} is an API handle for the buffer.
 
-  {changedtick} is the new value of |b:changedtick| for that buffer.
+    {changedtick} is the new value of |b:changedtick| for that buffer.
 
 nvim_buf_updates_end[{buf}]                                    		*nvim_buf_updates_end*
 
-  {buf} is an API handle for the buffer.
-
   Indicates that buffer updates for the nominated buffer have been disabled,
   either by calling |nvim_buf_detach| or because the buffer was unloaded
   (see |buffer-updates-limitations| for more information).
 
+    {buf} is an API handle for the buffer.
+
+
                                                       *buffer-updates-limitations*
 Limitations~
 
diff --git a/src/nvim/buffer_updates.c b/src/nvim/buffer_updates.c
index 8eac695efe..71ca800ee5 100644
--- a/src/nvim/buffer_updates.c
+++ b/src/nvim/buffer_updates.c
@@ -28,39 +28,50 @@ bool buf_updates_register(buf_T *buf, uint64_t channel_id, bool send_buffer)
   // append the channelid to the list
   kv_push(buf->update_channels, channel_id);
 
-  Array linedata = ARRAY_DICT_INIT;
-  if (send_buffer) {
-    // collect buffer contents
-    // True now, but a compile time reminder for future systems we support
-    STATIC_ASSERT(SIZE_MAX >= MAXLNUM, "size_t to small to hold the number of"
-                  " lines in a buffer");
-    size_t line_count = (size_t)buf->b_ml.ml_line_count;
-    linedata.size = line_count;
-    linedata.items = xcalloc(sizeof(Object), line_count);
-    for (size_t i = 0; i < line_count; i++) {
-      linenr_T lnum = 1 + (linenr_T)i;
-
-      const char *bufstr = (char *)ml_get_buf(buf, lnum, false);
-      Object str = STRING_OBJ(cstr_to_string(bufstr));
-
-      // Vim represents NULs as NLs, but this may confuse clients.
-      strchrsub(str.data.string.data, '\n', '\0');
-
-      linedata.items[i] = str;
-    }
-  }
-
   Array args = ARRAY_DICT_INIT;
-  args.size = 4;
+  args.size = 6;
   args.items = xcalloc(sizeof(Object), args.size);
 
   // the first argument is always the buffer handle
   args.items[0] = BUFFER_OBJ(buf->handle);
   args.items[1] = INTEGER_OBJ(buf->b_changedtick);
-  args.items[2] = ARRAY_OBJ(linedata);
-  args.items[3] = BOOLEAN_OBJ(false);
+  // the first line that changed (zero-indexed)
+  args.items[2] = INTEGER_OBJ(-1);
+  // the last line that was changed
+  args.items[3] = INTEGER_OBJ(-1);
+  Array linedata = ARRAY_DICT_INIT;
 
-  rpc_send_event(channel_id, "nvim_buf_updates_start", args);
+  if (send_buffer) {
+    // collect buffer contents
+
+    // True now, but a compile time reminder for future systems we support
+    STATIC_ASSERT(SIZE_MAX >= MAXLNUM, "size_t to small to hold the number of"
+                  " lines in a buffer");
+    size_t line_count = (size_t)buf->b_ml.ml_line_count;
+
+    if (line_count >= 1) {
+      args.items[2] = INTEGER_OBJ(0);
+
+      linedata.size = line_count;
+      linedata.items = xcalloc(sizeof(Object), line_count);
+      for (size_t i = 0; i < line_count; i++) {
+        linenr_T lnum = 1 + (linenr_T)i;
+
+        const char *bufstr = (char *)ml_get_buf(buf, lnum, false);
+        Object str = STRING_OBJ(cstr_to_string(bufstr));
+
+        // Vim represents NULs as NLs, but this may confuse clients.
+        strchrsub(str.data.string.data, '\n', '\0');
+
+        linedata.items[i] = str;
+      }
+    }
+  }
+
+  args.items[4] = ARRAY_OBJ(linedata);
+  args.items[5] = BOOLEAN_OBJ(false);
+
+  rpc_send_event(channel_id, "nvim_buf_lines_event", args);
   return true;
 }
 
@@ -137,7 +148,7 @@ void buf_updates_send_changes(buf_T *buf,
 
     // send through the changes now channel contents now
     Array args = ARRAY_DICT_INIT;
-    args.size = 5;
+    args.size = 6;
     args.items = xcalloc(sizeof(Object), args.size);
 
     // the first argument is always the buffer handle
@@ -174,7 +185,8 @@ void buf_updates_send_changes(buf_T *buf,
         }
     }
     args.items[4] = ARRAY_OBJ(linedata);
-    if (!rpc_send_event(channelid, "nvim_buf_update", args)) {
+    args.items[5] = BOOLEAN_OBJ(false);
+    if (!rpc_send_event(channelid, "nvim_buf_lines_event", args)) {
       // We can't unregister the channel while we're iterating over the
       // update_channels array, so we remember its ID to unregister it at
       // the end.
diff --git a/test/functional/api/buffer_updates_spec.lua b/test/functional/api/buffer_updates_spec.lua
index 0eec59bd65..3f15c8a8a5 100644
--- a/test/functional/api/buffer_updates_spec.lua
+++ b/test/functional/api/buffer_updates_spec.lua
@@ -32,11 +32,12 @@ local function open(activate, lines)
   -- what is the value of b:changedtick?
   local tick = eval('b:changedtick')
 
-  -- turn on live updates, ensure that the nvim_buf_updates_start messages
+  -- turn on live updates, ensure that the nvim_buf_lines_event messages
   -- arrive as expectected
   if activate then
+    local firstline = 0
     ok(buffer('attach', b, true))
-    expectn('nvim_buf_updates_start', {b, tick, lines, false})
+    expectn('nvim_buf_lines_event', {b, tick, firstline, -1, lines, false})
   end
 
   return b, tick, filename
@@ -58,7 +59,8 @@ local function reopen(buf, expectedlines)
   command('edit!')
   local tick = eval('b:changedtick')
   ok(buffer('attach', buf, true))
-  expectn('nvim_buf_updates_start', {buf, tick, expectedlines, false})
+  local firstline = 0
+  expectn('nvim_buf_lines_event', {buf, tick, firstline, -1, expectedlines, false})
   command('normal! gg')
   return tick
 end
@@ -73,18 +75,18 @@ local function reopenwithfolds(b)
   -- add a fold
   command('2,4fold')
   tick = tick + 1
-  expectn('nvim_buf_update', {b, tick, 1, 4, {'original line 2/*{{{*/',
+  expectn('nvim_buf_lines_event', {b, tick, 1, 4, {'original line 2/*{{{*/',
                                           'original line 3',
-                                          'original line 4/*}}}*/'}})
+                                          'original line 4/*}}}*/'}, false})
   -- make a new fold that wraps lines 1-6
   command('1,6fold')
   tick = tick + 1
-  expectn('nvim_buf_update', {b, tick, 0, 6, {'original line 1/*{{{*/',
+  expectn('nvim_buf_lines_event', {b, tick, 0, 6, {'original line 1/*{{{*/',
                                           'original line 2/*{{{*/',
                                           'original line 3',
                                           'original line 4/*}}}*/',
                                           'original line 5',
-                                          'original line 6/*}}}*/'}})
+                                          'original line 6/*}}}*/'}, false})
   return tick
 end
 
@@ -95,47 +97,47 @@ describe('buffer events', function()
     -- add a new line at the start of the buffer
     command('normal! GyyggP')
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 0, 0, {'original line 6'}})
+    expectn('nvim_buf_lines_event', {b, tick, 0, 0, {'original line 6'}, false})
 
     -- add multiple lines at the start of the file
     command('normal! GkkyGggP')
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 0, 0, {'original line 4',
+    expectn('nvim_buf_lines_event', {b, tick, 0, 0, {'original line 4',
                                            'original line 5',
-                                           'original line 6'}})
+                                           'original line 6'}, false})
 
     -- add one line to the middle of the file, several times
     command('normal! ggYjjp')
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 3, 3, {'original line 4'}})
+    expectn('nvim_buf_lines_event', {b, tick, 3, 3, {'original line 4'}, false})
     command('normal! p')
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 4, 4, {'original line 4'}})
+    expectn('nvim_buf_lines_event', {b, tick, 4, 4, {'original line 4'}, false})
     command('normal! p')
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 5, 5, {'original line 4'}})
+    expectn('nvim_buf_lines_event', {b, tick, 5, 5, {'original line 4'}, false})
 
     -- add multiple lines to the middle of the file
     command('normal! gg4Yjjp')
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 3, 3, {'original line 4',
+    expectn('nvim_buf_lines_event', {b, tick, 3, 3, {'original line 4',
                                            'original line 5',
                                            'original line 6',
-                                           'original line 4'}})
+                                           'original line 4'}, false})
 
     -- add one line to the end of the file
     command('normal! ggYGp')
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 17, 17, {'original line 4'}})
+    expectn('nvim_buf_lines_event', {b, tick, 17, 17, {'original line 4'}, false})
 
     -- add one line to the end of the file, several times
     command('normal! ggYGppp')
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 18, 18, {'original line 4'}})
+    expectn('nvim_buf_lines_event', {b, tick, 18, 18, {'original line 4'}, false})
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 19, 19, {'original line 4'}})
+    expectn('nvim_buf_lines_event', {b, tick, 19, 19, {'original line 4'}, false})
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 20, 20, {'original line 4'}})
+    expectn('nvim_buf_lines_event', {b, tick, 20, 20, {'original line 4'}, false})
 
     -- add several lines to the end of the file, several times
     command('normal! gg4YGp')
@@ -146,11 +148,11 @@ describe('buffer events', function()
                  'original line 6',
                  'original line 4'}
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 21, 21, firstfour})
+    expectn('nvim_buf_lines_event', {b, tick, 21, 21, firstfour, false})
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 25, 25, firstfour})
+    expectn('nvim_buf_lines_event', {b, tick, 25, 25, firstfour, false})
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 29, 29, firstfour})
+    expectn('nvim_buf_lines_event', {b, tick, 29, 29, firstfour, false})
 
     -- create a new empty buffer and wipe out the old one ... this will
     -- turn off live updates
@@ -162,10 +164,10 @@ describe('buffer events', function()
     tick = eval('b:changedtick')
     local b2 = nvim('get_current_buf')
     ok(buffer('attach', b2, true))
-    expectn('nvim_buf_updates_start', {b2, tick, {""}, false})
+    expectn('nvim_buf_lines_event', {b2, tick, 0, -1, {""}, false})
     eval('append(0, ["new line 1"])')
     tick = tick + 1
-    expectn('nvim_buf_update', {b2, tick, 0, 0, {'new line 1'}})
+    expectn('nvim_buf_lines_event', {b2, tick, 0, 0, {'new line 1'}, false})
 
     -- turn off live updates manually
     buffer('detach', b2)
@@ -176,17 +178,17 @@ describe('buffer events', function()
     local b3 = nvim('get_current_buf')
     ok(buffer('attach', b3, true))
     tick = eval('b:changedtick')
-    expectn('nvim_buf_updates_start', {b3, tick, {""}, false})
+    expectn('nvim_buf_lines_event', {b3, tick, 0, -1, {""}, false})
     eval('append(0, ["new line 1", "new line 2", "new line 3"])')
     tick = tick + 1
-    expectn('nvim_buf_update', {b3, tick, 0, 0, {'new line 1',
+    expectn('nvim_buf_lines_event', {b3, tick, 0, 0, {'new line 1',
                                             'new line 2',
-                                            'new line 3'}})
+                                            'new line 3'}, false})
 
     -- use the API itself to add a line to the start of the buffer
     buffer('set_lines', b3, 0, 0, true, {'New First Line'})
     tick = tick + 1
-    expectn('nvim_buf_update', {b3, tick, 0, 0, {"New First Line"}})
+    expectn('nvim_buf_lines_event', {b3, tick, 0, 0, {"New First Line"}, false})
   end)
 
   it('knows when you remove lines from a buffer', function()
@@ -195,37 +197,37 @@ describe('buffer events', function()
     -- remove one line from start of file
     command('normal! dd')
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 0, 1, {}})
+    expectn('nvim_buf_lines_event', {b, tick, 0, 1, {}, false})
 
     -- remove multiple lines from the start of the file
     command('normal! 4dd')
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 0, 4, {}})
+    expectn('nvim_buf_lines_event', {b, tick, 0, 4, {}, false})
 
     -- remove multiple lines from middle of file
     tick = reopen(b, origlines)
     command('normal! jj3dd')
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 2, 5, {}})
+    expectn('nvim_buf_lines_event', {b, tick, 2, 5, {}, false})
 
     -- remove one line from the end of the file
     tick = reopen(b, origlines)
     command('normal! Gdd')
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 5, 6, {}})
+    expectn('nvim_buf_lines_event', {b, tick, 5, 6, {}, false})
 
     -- remove multiple lines from the end of the file
     tick = reopen(b, origlines)
     command('normal! 4G3dd')
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 3, 6, {}})
+    expectn('nvim_buf_lines_event', {b, tick, 3, 6, {}, false})
 
     -- pretend to remove heaps lines from the end of the file but really
     -- just remove two
     tick = reopen(b, origlines)
     command('normal! Gk5dd')
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 4, 6, {}})
+    expectn('nvim_buf_lines_event', {b, tick, 4, 6, {}, false})
   end)
 
   it('knows when you modify lines of text', function()
@@ -234,32 +236,32 @@ describe('buffer events', function()
     -- some normal text editing
     command('normal! A555')
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 0, 1, {'original line 1555'}})
+    expectn('nvim_buf_lines_event', {b, tick, 0, 1, {'original line 1555'}, false})
     command('normal! jj8X')
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 2, 3, {'origin3'}})
+    expectn('nvim_buf_lines_event', {b, tick, 2, 3, {'origin3'}, false})
 
     -- modify multiple lines at once using visual block mode
     tick = reopen(b, origlines)
     command('normal! jjw')
     sendkeys('<C-v>jjllx')
     tick = tick + 1
-    expectn('nvim_buf_update',
-            {b, tick, 2, 5, {'original e 3', 'original e 4', 'original e 5'}})
+    expectn('nvim_buf_lines_event',
+            {b, tick, 2, 5, {'original e 3', 'original e 4', 'original e 5'}, false})
 
     -- replace part of a line line using :s
     tick = reopen(b, origlines)
     command('3s/line 3/foo/')
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 2, 3, {'original foo'}})
+    expectn('nvim_buf_lines_event', {b, tick, 2, 3, {'original foo'}, false})
 
     -- replace parts of several lines line using :s
     tick = reopen(b, origlines)
     command('%s/line [35]/foo/')
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 2, 5, {'original foo',
+    expectn('nvim_buf_lines_event', {b, tick, 2, 5, {'original foo',
                                            'original line 4',
-                                           'original foo'}})
+                                           'original foo'}, false})
 
     -- type text into the first line of a blank file, one character at a time
     command('enew!')
@@ -267,20 +269,20 @@ describe('buffer events', function()
     expectn('nvim_buf_updates_end', {b})
     local bnew = nvim('get_current_buf')
     ok(buffer('attach', bnew, true))
-    expectn('nvim_buf_updates_start', {bnew, tick, {''}, false})
+    expectn('nvim_buf_lines_event', {bnew, tick, 0, -1, {''}, false})
     sendkeys('i')
     sendkeys('h')
     sendkeys('e')
     sendkeys('l')
     sendkeys('l')
     sendkeys('o\nworld')
-    expectn('nvim_buf_update', {bnew, tick + 1, 0, 1, {'h'}})
-    expectn('nvim_buf_update', {bnew, tick + 2, 0, 1, {'he'}})
-    expectn('nvim_buf_update', {bnew, tick + 3, 0, 1, {'hel'}})
-    expectn('nvim_buf_update', {bnew, tick + 4, 0, 1, {'hell'}})
-    expectn('nvim_buf_update', {bnew, tick + 5, 0, 1, {'hello'}})
-    expectn('nvim_buf_update', {bnew, tick + 6, 0, 1, {'hello', ''}})
-    expectn('nvim_buf_update', {bnew, tick + 7, 1, 2, {'world'}})
+    expectn('nvim_buf_lines_event', {bnew, tick + 1, 0, 1, {'h'}, false})
+    expectn('nvim_buf_lines_event', {bnew, tick + 2, 0, 1, {'he'}, false})
+    expectn('nvim_buf_lines_event', {bnew, tick + 3, 0, 1, {'hel'}, false})
+    expectn('nvim_buf_lines_event', {bnew, tick + 4, 0, 1, {'hell'}, false})
+    expectn('nvim_buf_lines_event', {bnew, tick + 5, 0, 1, {'hello'}, false})
+    expectn('nvim_buf_lines_event', {bnew, tick + 6, 0, 1, {'hello', ''}, false})
+    expectn('nvim_buf_lines_event', {bnew, tick + 7, 1, 2, {'world'}, false})
   end)
 
   it('knows when you replace lines', function()
@@ -289,23 +291,23 @@ describe('buffer events', function()
     -- blast away parts of some lines with visual mode
     command('normal! jjwvjjllx')
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 2, 3, {'original '}})
+    expectn('nvim_buf_lines_event', {b, tick, 2, 3, {'original '}, false})
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 3, 4, {}})
+    expectn('nvim_buf_lines_event', {b, tick, 3, 4, {}, false})
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 3, 4, {'e 5'}})
+    expectn('nvim_buf_lines_event', {b, tick, 3, 4, {'e 5'}, false})
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 2, 3, {'original e 5'}})
+    expectn('nvim_buf_lines_event', {b, tick, 2, 3, {'original e 5'}, false})
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 3, 4, {}})
+    expectn('nvim_buf_lines_event', {b, tick, 3, 4, {}, false})
 
     -- blast away a few lines using :g
     tick = reopen(b, origlines)
     command('global/line [35]/delete')
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 2, 3, {}})
+    expectn('nvim_buf_lines_event', {b, tick, 2, 3, {}, false})
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 3, 4, {}})
+    expectn('nvim_buf_lines_event', {b, tick, 3, 4, {}, false})
   end)
 
   it('knows when you filter lines', function()
@@ -317,9 +319,9 @@ describe('buffer events', function()
     -- 1) addition of the new lines after the filtered lines
     -- 2) removal of the original lines
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 5, 5, {"C", "E", "B", "D"}})
+    expectn('nvim_buf_lines_event', {b, tick, 5, 5, {"C", "E", "B", "D"}, false})
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 1, 5, {}})
+    expectn('nvim_buf_lines_event', {b, tick, 1, 5, {}, false})
   end)
 
   it('sends a sensible event when you use "o"', function()
@@ -329,37 +331,37 @@ describe('buffer events', function()
     -- use 'o' to start a new line from a line with no indent
     command('normal! o')
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 1, 1, {""}})
+    expectn('nvim_buf_lines_event', {b, tick, 1, 1, {""}, false})
 
     -- undo the change, indent line 1 a bit, and try again
     command('undo')
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 1, 2, {}})
+    expectn('nvim_buf_lines_event', {b, tick, 1, 2, {}, false})
     tick = tick + 1
     expectn('nvim_buf_changedtick', {b, tick})
     command('set autoindent')
     command('normal! >>')
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 0, 1, {"\tAAA"}})
+    expectn('nvim_buf_lines_event', {b, tick, 0, 1, {"\tAAA"}, false})
     command('normal! ommm')
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 1, 1, {"\t"}})
+    expectn('nvim_buf_lines_event', {b, tick, 1, 1, {"\t"}, false})
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 1, 2, {"\tmmm"}})
+    expectn('nvim_buf_lines_event', {b, tick, 1, 2, {"\tmmm"}, false})
 
     -- undo the change, and try again with 'O'
     command('undo')
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 1, 2, {'\t'}})
+    expectn('nvim_buf_lines_event', {b, tick, 1, 2, {'\t'}, false})
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 1, 2, {}})
+    expectn('nvim_buf_lines_event', {b, tick, 1, 2, {}, false})
     tick = tick + 1
     expectn('nvim_buf_changedtick', {b, tick})
     command('normal! ggOmmm')
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 0, 0, {"\t"}})
+    expectn('nvim_buf_lines_event', {b, tick, 0, 0, {"\t"}, false})
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 0, 1, {"\tmmm"}})
+    expectn('nvim_buf_lines_event', {b, tick, 0, 1, {"\tmmm"}, false})
   end)
 
   it('deactivates when your buffer changes outside vim', function()
@@ -369,10 +371,10 @@ describe('buffer events', function()
 
     command('normal! x')
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 0, 1, {'ine 1'}})
+    expectn('nvim_buf_lines_event', {b, tick, 0, 1, {'ine 1'}, false})
     command('undo')
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 0, 1, {'Line 1'}})
+    expectn('nvim_buf_lines_event', {b, tick, 0, 1, {'Line 1'}, false})
     tick = tick + 1
     expectn('nvim_buf_changedtick', {b, tick})
 
@@ -405,30 +407,30 @@ describe('buffer events', function()
     command('b'..b1nr)
     command('normal! x')
     tick1 = tick1 + 1
-    expectn('nvim_buf_update', {b1, tick1, 0, 1, {'1'}})
+    expectn('nvim_buf_lines_event', {b1, tick1, 0, 1, {'1'}, false})
     command('undo')
     tick1 = tick1 + 1
-    expectn('nvim_buf_update', {b1, tick1, 0, 1, {'A1'}})
+    expectn('nvim_buf_lines_event', {b1, tick1, 0, 1, {'A1'}, false})
     tick1 = tick1 + 1
     expectn('nvim_buf_changedtick', {b1, tick1})
 
     command('b'..b2nr)
     command('normal! x')
     tick2 = tick2 + 1
-    expectn('nvim_buf_update', {b2, tick2, 0, 1, {'1'}})
+    expectn('nvim_buf_lines_event', {b2, tick2, 0, 1, {'1'}, false})
     command('undo')
     tick2 = tick2 + 1
-    expectn('nvim_buf_update', {b2, tick2, 0, 1, {'B1'}})
+    expectn('nvim_buf_lines_event', {b2, tick2, 0, 1, {'B1'}, false})
     tick2 = tick2 + 1
     expectn('nvim_buf_changedtick', {b2, tick2})
 
     command('b'..b3nr)
     command('normal! x')
     tick3 = tick3 + 1
-    expectn('nvim_buf_update', {b3, tick3, 0, 1, {'1'}})
+    expectn('nvim_buf_lines_event', {b3, tick3, 0, 1, {'1'}, false})
     command('undo')
     tick3 = tick3 + 1
-    expectn('nvim_buf_update', {b3, tick3, 0, 1, {'C1'}})
+    expectn('nvim_buf_lines_event', {b3, tick3, 0, 1, {'C1'}, false})
     tick3 = tick3 + 1
     expectn('nvim_buf_changedtick', {b3, tick3})
   end)
@@ -444,7 +446,7 @@ describe('buffer events', function()
     ok(buffer('attach', b, true))
     ok(buffer('attach', b, true))
     ok(buffer('attach', b, true))
-    expectn('nvim_buf_updates_start', {b, tick, origlines, false})
+    expectn('nvim_buf_lines_event', {b, tick, 0, -1, origlines, false})
     eval('rpcnotify('..channel..', "Hello There")')
     expectn('Hello There', {})
 
@@ -491,16 +493,16 @@ describe('buffer events', function()
     ok(request(1, 'nvim_buf_attach', b, true))
     ok(request(2, 'nvim_buf_attach', b, true))
     ok(request(3, 'nvim_buf_attach', b, true))
-    wantn(1, 'nvim_buf_updates_start', {b, tick, lines, false})
-    wantn(2, 'nvim_buf_updates_start', {b, tick, lines, false})
-    wantn(3, 'nvim_buf_updates_start', {b, tick, lines, false})
+    wantn(1, 'nvim_buf_lines_event', {b, tick, 0, -1, lines, false})
+    wantn(2, 'nvim_buf_lines_event', {b, tick, 0, -1, lines, false})
+    wantn(3, 'nvim_buf_lines_event', {b, tick, 0, -1, lines, false})
 
     -- make a change to the buffer
     command('normal! x')
     tick = tick + 1
-    wantn(1, 'nvim_buf_update', {b, tick, 0, 1, {'AA'}})
-    wantn(2, 'nvim_buf_update', {b, tick, 0, 1, {'AA'}})
-    wantn(3, 'nvim_buf_update', {b, tick, 0, 1, {'AA'}})
+    wantn(1, 'nvim_buf_lines_event', {b, tick, 0, 1, {'AA'}, false})
+    wantn(2, 'nvim_buf_lines_event', {b, tick, 0, 1, {'AA'}, false})
+    wantn(3, 'nvim_buf_lines_event', {b, tick, 0, 1, {'AA'}, false})
 
     -- stop watching on channel 1
     ok(request(1, 'nvim_buf_detach', b))
@@ -509,13 +511,13 @@ describe('buffer events', function()
     -- undo the change to buffer 1
     command('undo')
     tick = tick + 1
-    wantn(2, 'nvim_buf_update', {b, tick, 0, 1, {'AAA'}})
-    wantn(3, 'nvim_buf_update', {b, tick, 0, 1, {'AAA'}})
+    wantn(2, 'nvim_buf_lines_event', {b, tick, 0, 1, {'AAA'}, false})
+    wantn(3, 'nvim_buf_lines_event', {b, tick, 0, 1, {'AAA'}, false})
     tick = tick + 1
     wantn(2, 'nvim_buf_changedtick', {b, tick})
     wantn(3, 'nvim_buf_changedtick', {b, tick})
 
-    -- make sure there are no other pending nvim_buf_update messages going to
+    -- make sure there are no other pending nvim_buf_lines_event messages going to
     -- channel 1
     local channel1 = request(1, 'nvim_get_api_info')[1]
     eval('rpcnotify('..channel1..', "Hello")')
@@ -527,7 +529,7 @@ describe('buffer events', function()
     wantn(2, 'nvim_buf_updates_end', {b})
     wantn(3, 'nvim_buf_updates_end', {b})
 
-    -- make sure there are no other pending nvim_buf_update messages going to
+    -- make sure there are no other pending nvim_buf_lines_event messages going to
     -- channel 1
     channel1 = request(1, 'nvim_get_api_info')[1]
     eval('rpcnotify('..channel1..', "Hello Again")')
@@ -550,13 +552,13 @@ describe('buffer events', function()
     command('normal! gg')
     command('diffput')
     tick2 = tick2 + 1
-    expectn('nvim_buf_update', {b2, tick2, 0, 0, {"AAA"}})
+    expectn('nvim_buf_lines_event', {b2, tick2, 0, 0, {"AAA"}, false})
 
     -- use :diffget to grab the other change from buffer 2
     command('normal! G')
     command('diffget')
     tick1 = tick1 + 1
-    expectn('nvim_buf_update', {b1, tick1, 2, 2, {"CCC"}})
+    expectn('nvim_buf_lines_event', {b1, tick1, 2, 2, {"CCC"}, false})
 
     eval('rpcnotify('..channel..', "Goodbye")')
     expectn('Goodbye', {})
@@ -567,14 +569,14 @@ describe('buffer events', function()
     local b, tick = editoriginal(true, {"B", "D", "C", "A", "E"})
     command('%sort')
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 0, 5, {"A", "B", "C", "D", "E"}})
+    expectn('nvim_buf_lines_event', {b, tick, 0, 5, {"A", "B", "C", "D", "E"}, false})
   end)
 
   it('works with :left', function()
     local b, tick = editoriginal(true, {" A", "  B", "B", "\tB", "\t\tC"})
     command('2,4left')
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 1, 4, {"B", "B", "B"}})
+    expectn('nvim_buf_lines_event', {b, tick, 1, 4, {"B", "B", "B"}, false})
   end)
 
   it('works with :right', function()
@@ -586,7 +588,7 @@ describe('buffer events', function()
     command('set ts=2 et')
     command('2,4retab')
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 1, 4, {"    B", "      BB", "  B"}})
+    expectn('nvim_buf_lines_event', {b, tick, 1, 4, {"    B", "      BB", "  B"}, false})
   end)
 
   it('works with :move', function()
@@ -594,19 +596,19 @@ describe('buffer events', function()
     -- move text down towards the end of the file
     command('2,3move 4')
     tick = tick + 2
-    expectn('nvim_buf_update', {b, tick, 4, 4, {"original line 2",
-                                           "original line 3"}})
+    expectn('nvim_buf_lines_event', {b, tick, 4, 4, {"original line 2",
+                                           "original line 3"}, false})
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 1, 3, {}})
+    expectn('nvim_buf_lines_event', {b, tick, 1, 3, {}, false})
 
     -- move text up towards the start of the file
     tick = reopen(b, origlines)
     command('4,5move 2')
     tick = tick + 2
-    expectn('nvim_buf_update', {b, tick, 2, 2, {"original line 4",
-                                           "original line 5"}})
+    expectn('nvim_buf_lines_event', {b, tick, 2, 2, {"original line 4",
+                                           "original line 5"}, false})
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 5, 7, {}})
+    expectn('nvim_buf_lines_event', {b, tick, 5, 7, {}, false})
   end)
 
   it('sends sensible events when you manually add/remove folds', function()
@@ -616,13 +618,13 @@ describe('buffer events', function()
     -- delete the inner fold
     command('normal! zR3Gzd')
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 1, 4, {'original line 2',
+    expectn('nvim_buf_lines_event', {b, tick, 1, 4, {'original line 2',
                                            'original line 3',
-                                           'original line 4'}})
+                                           'original line 4'}, false})
     -- delete the outer fold
     command('normal! zd')
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 0, 6, origlines})
+    expectn('nvim_buf_lines_event', {b, tick, 0, 6, origlines, false})
 
     -- discard changes and put the folds back
     tick = reopenwithfolds(b)
@@ -630,7 +632,7 @@ describe('buffer events', function()
     -- remove both folds at once
     command('normal! ggzczD')
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 0, 6, origlines})
+    expectn('nvim_buf_lines_event', {b, tick, 0, 6, origlines, false})
 
     -- discard changes and put the folds back
     tick = reopenwithfolds(b)
@@ -638,19 +640,19 @@ describe('buffer events', function()
     -- now delete all folds at once
     command('normal! zE')
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 0, 6, origlines})
+    expectn('nvim_buf_lines_event', {b, tick, 0, 6, origlines, false})
 
     -- create a fold from line 4 to the end of the file
     command('normal! 4GA/*{{{*/')
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 3, 4, {'original line 4/*{{{*/'}})
+    expectn('nvim_buf_lines_event', {b, tick, 3, 4, {'original line 4/*{{{*/'}, false})
 
     -- delete the fold which only has one marker
     command('normal! Gzd')
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 3, 6, {'original line 4',
+    expectn('nvim_buf_lines_event', {b, tick, 3, 6, {'original line 4',
                                            'original line 5',
-                                           'original line 6'}})
+                                           'original line 6'}, false})
   end)
 
   it('turns off updates when a buffer is closed', function()
@@ -660,10 +662,10 @@ describe('buffer events', function()
     -- test live updates are working
     command('normal! x')
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 0, 1, {'AA'}})
+    expectn('nvim_buf_lines_event', {b, tick, 0, 1, {'AA'}, false})
     command('undo')
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 0, 1, {'AAA'}})
+    expectn('nvim_buf_lines_event', {b, tick, 0, 1, {'AAA'}, false})
     tick = tick + 1
     expectn('nvim_buf_changedtick', {b, tick})
 
@@ -687,10 +689,10 @@ describe('buffer events', function()
     -- test live updates are working
     command('normal! x')
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 0, 1, {'AA'}})
+    expectn('nvim_buf_lines_event', {b, tick, 0, 1, {'AA'}, false})
     command('undo')
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 0, 1, {'AAA'}})
+    expectn('nvim_buf_lines_event', {b, tick, 0, 1, {'AAA'}, false})
     tick = tick + 1
     expectn('nvim_buf_changedtick', {b, tick})
 
@@ -706,7 +708,7 @@ describe('buffer events', function()
     command('b1')
     command('normal! x')
     tick = tick + 1
-    expectn('nvim_buf_update', {b, tick, 0, 1, {'AA'}})
+    expectn('nvim_buf_lines_event', {b, tick, 0, 1, {'AA'}, false})
   end)
 
   it('turns off live updates when a buffer is unloaded, deleted, or wiped',
@@ -731,7 +733,7 @@ describe('buffer events', function()
     helpers.clear()
     local b, tick = editoriginal(false)
     ok(buffer('attach', b, false))
-    expectn('nvim_buf_updates_start', {b, tick, {}, false})
+    expectn('nvim_buf_lines_event', {b, tick, -1, -1, {}, false})
   end)
 
 end)

From 0bee3925ab5186211f10c823d4f149d4d16eb7a5 Mon Sep 17 00:00:00 2001
From: KillTheMule <KillTheMule@users.noreply.github.com>
Date: Thu, 10 May 2018 23:13:58 +0200
Subject: [PATCH 23/26] Send changedtick as first event if buffer contents
 weren't requested

---
 src/nvim/api/buffer.c                       |  4 +-
 src/nvim/buffer_updates.c                   | 50 +++++++++++----------
 test/functional/api/buffer_updates_spec.lua | 22 ++++-----
 3 files changed, 41 insertions(+), 35 deletions(-)

diff --git a/src/nvim/api/buffer.c b/src/nvim/api/buffer.c
index 756367f801..12d1feb370 100644
--- a/src/nvim/api/buffer.c
+++ b/src/nvim/api/buffer.c
@@ -80,7 +80,9 @@ String buffer_get_line(Buffer buffer, Integer index, Error *err)
 ///
 /// @param buffer The buffer handle
 /// @param send_buffer Set to true if the initial notification should contain
-///        the whole buffer
+///        the whole buffer. If so, the first notification will be a
+///        `nvim_buf_lines_event`. Otherwise, the first notification will be
+///        a `nvim_buf_changedtick_event`
 /// @param[out] err Details of an error that may have occurred
 /// @return False when updates couldn't be enabled because the buffer isn't
 ///         loaded; otherwise True.
diff --git a/src/nvim/buffer_updates.c b/src/nvim/buffer_updates.c
index 71ca800ee5..2852561ce0 100644
--- a/src/nvim/buffer_updates.c
+++ b/src/nvim/buffer_updates.c
@@ -28,20 +28,20 @@ bool buf_updates_register(buf_T *buf, uint64_t channel_id, bool send_buffer)
   // append the channelid to the list
   kv_push(buf->update_channels, channel_id);
 
-  Array args = ARRAY_DICT_INIT;
-  args.size = 6;
-  args.items = xcalloc(sizeof(Object), args.size);
-
-  // the first argument is always the buffer handle
-  args.items[0] = BUFFER_OBJ(buf->handle);
-  args.items[1] = INTEGER_OBJ(buf->b_changedtick);
-  // the first line that changed (zero-indexed)
-  args.items[2] = INTEGER_OBJ(-1);
-  // the last line that was changed
-  args.items[3] = INTEGER_OBJ(-1);
-  Array linedata = ARRAY_DICT_INIT;
-
   if (send_buffer) {
+    Array args = ARRAY_DICT_INIT;
+    args.size = 6;
+    args.items = xcalloc(sizeof(Object), args.size);
+
+    // the first argument is always the buffer handle
+    args.items[0] = BUFFER_OBJ(buf->handle);
+    args.items[1] = INTEGER_OBJ(buf->b_changedtick);
+    // the first line that changed (zero-indexed)
+    args.items[2] = INTEGER_OBJ(0);
+    // the last line that was changed
+    args.items[3] = INTEGER_OBJ(-1);
+    Array linedata = ARRAY_DICT_INIT;
+
     // collect buffer contents
 
     // True now, but a compile time reminder for future systems we support
@@ -50,8 +50,6 @@ bool buf_updates_register(buf_T *buf, uint64_t channel_id, bool send_buffer)
     size_t line_count = (size_t)buf->b_ml.ml_line_count;
 
     if (line_count >= 1) {
-      args.items[2] = INTEGER_OBJ(0);
-
       linedata.size = line_count;
       linedata.items = xcalloc(sizeof(Object), line_count);
       for (size_t i = 0; i < line_count; i++) {
@@ -66,12 +64,15 @@ bool buf_updates_register(buf_T *buf, uint64_t channel_id, bool send_buffer)
         linedata.items[i] = str;
       }
     }
+
+    args.items[4] = ARRAY_OBJ(linedata);
+    args.items[5] = BOOLEAN_OBJ(false);
+
+    rpc_send_event(channel_id, "nvim_buf_lines_event", args);
+  } else {
+    buf_updates_changedtick_single(buf, channel_id);
   }
 
-  args.items[4] = ARRAY_OBJ(linedata);
-  args.items[5] = BOOLEAN_OBJ(false);
-
-  rpc_send_event(channel_id, "nvim_buf_lines_event", args);
   return true;
 }
 
@@ -207,9 +208,13 @@ void buf_updates_changedtick(buf_T *buf)
 {
   // notify each of the active channels
   for (size_t i = 0; i < kv_size(buf->update_channels); i++) {
-    uint64_t channelid = kv_A(buf->update_channels, i);
+    uint64_t channel_id = kv_A(buf->update_channels, i);
+    buf_updates_changedtick_single(buf, channel_id);
+  }
+}
 
-    // send through the changes now channel contents now
+void buf_updates_changedtick_single(buf_T *buf, uint64_t channel_id)
+{
     Array args = ARRAY_DICT_INIT;
     args.size = 2;
     args.items = xcalloc(sizeof(Object), args.size);
@@ -221,6 +226,5 @@ void buf_updates_changedtick(buf_T *buf)
     args.items[1] = INTEGER_OBJ(buf->b_changedtick);
 
     // don't try and clean up dead channels here
-    rpc_send_event(channelid, "nvim_buf_changedtick", args);
-  }
+    rpc_send_event(channel_id, "nvim_buf_changedtick_event", args);
 }
diff --git a/test/functional/api/buffer_updates_spec.lua b/test/functional/api/buffer_updates_spec.lua
index 3f15c8a8a5..1bbba91187 100644
--- a/test/functional/api/buffer_updates_spec.lua
+++ b/test/functional/api/buffer_updates_spec.lua
@@ -338,7 +338,7 @@ describe('buffer events', function()
     tick = tick + 1
     expectn('nvim_buf_lines_event', {b, tick, 1, 2, {}, false})
     tick = tick + 1
-    expectn('nvim_buf_changedtick', {b, tick})
+    expectn('nvim_buf_changedtick_event', {b, tick})
     command('set autoindent')
     command('normal! >>')
     tick = tick + 1
@@ -356,7 +356,7 @@ describe('buffer events', function()
     tick = tick + 1
     expectn('nvim_buf_lines_event', {b, tick, 1, 2, {}, false})
     tick = tick + 1
-    expectn('nvim_buf_changedtick', {b, tick})
+    expectn('nvim_buf_changedtick_event', {b, tick})
     command('normal! ggOmmm')
     tick = tick + 1
     expectn('nvim_buf_lines_event', {b, tick, 0, 0, {"\t"}, false})
@@ -376,7 +376,7 @@ describe('buffer events', function()
     tick = tick + 1
     expectn('nvim_buf_lines_event', {b, tick, 0, 1, {'Line 1'}, false})
     tick = tick + 1
-    expectn('nvim_buf_changedtick', {b, tick})
+    expectn('nvim_buf_changedtick_event', {b, tick})
 
     -- change the file directly
     local f = io.open(filename, 'a')
@@ -412,7 +412,7 @@ describe('buffer events', function()
     tick1 = tick1 + 1
     expectn('nvim_buf_lines_event', {b1, tick1, 0, 1, {'A1'}, false})
     tick1 = tick1 + 1
-    expectn('nvim_buf_changedtick', {b1, tick1})
+    expectn('nvim_buf_changedtick_event', {b1, tick1})
 
     command('b'..b2nr)
     command('normal! x')
@@ -422,7 +422,7 @@ describe('buffer events', function()
     tick2 = tick2 + 1
     expectn('nvim_buf_lines_event', {b2, tick2, 0, 1, {'B1'}, false})
     tick2 = tick2 + 1
-    expectn('nvim_buf_changedtick', {b2, tick2})
+    expectn('nvim_buf_changedtick_event', {b2, tick2})
 
     command('b'..b3nr)
     command('normal! x')
@@ -432,7 +432,7 @@ describe('buffer events', function()
     tick3 = tick3 + 1
     expectn('nvim_buf_lines_event', {b3, tick3, 0, 1, {'C1'}, false})
     tick3 = tick3 + 1
-    expectn('nvim_buf_changedtick', {b3, tick3})
+    expectn('nvim_buf_changedtick_event', {b3, tick3})
   end)
 
   it('doesn\'t get confused when you turn watching on/off many times',
@@ -514,8 +514,8 @@ describe('buffer events', function()
     wantn(2, 'nvim_buf_lines_event', {b, tick, 0, 1, {'AAA'}, false})
     wantn(3, 'nvim_buf_lines_event', {b, tick, 0, 1, {'AAA'}, false})
     tick = tick + 1
-    wantn(2, 'nvim_buf_changedtick', {b, tick})
-    wantn(3, 'nvim_buf_changedtick', {b, tick})
+    wantn(2, 'nvim_buf_changedtick_event', {b, tick})
+    wantn(3, 'nvim_buf_changedtick_event', {b, tick})
 
     -- make sure there are no other pending nvim_buf_lines_event messages going to
     -- channel 1
@@ -667,7 +667,7 @@ describe('buffer events', function()
     tick = tick + 1
     expectn('nvim_buf_lines_event', {b, tick, 0, 1, {'AAA'}, false})
     tick = tick + 1
-    expectn('nvim_buf_changedtick', {b, tick})
+    expectn('nvim_buf_changedtick_event', {b, tick})
 
     -- close our buffer by creating a new one
     command('enew')
@@ -694,7 +694,7 @@ describe('buffer events', function()
     tick = tick + 1
     expectn('nvim_buf_lines_event', {b, tick, 0, 1, {'AAA'}, false})
     tick = tick + 1
-    expectn('nvim_buf_changedtick', {b, tick})
+    expectn('nvim_buf_changedtick_event', {b, tick})
 
     -- close our buffer by creating a new one
     command('set hidden')
@@ -733,7 +733,7 @@ describe('buffer events', function()
     helpers.clear()
     local b, tick = editoriginal(false)
     ok(buffer('attach', b, false))
-    expectn('nvim_buf_lines_event', {b, tick, -1, -1, {}, false})
+    expectn('nvim_buf_changedtick_event', {b, tick})
   end)
 
 end)

From 65e7f6f0b97b02e323488e06bf0f5df93bbcbf93 Mon Sep 17 00:00:00 2001
From: KillTheMule <KillTheMule@users.noreply.github.com>
Date: Fri, 18 May 2018 10:09:11 +0200
Subject: [PATCH 24/26] Rename some more, fixe borked renaming

---
 runtime/doc/msgpack_rpc.txt                 | 32 ++++++++++++---------
 src/nvim/buffer_updates.c                   |  2 +-
 src/nvim/ex_cmds.c                          |  2 +-
 src/nvim/fold.c                             |  4 +--
 src/nvim/misc1.c                            |  6 ++--
 src/nvim/terminal.c                         |  2 +-
 src/nvim/undo.c                             |  6 ++--
 test/functional/api/buffer_updates_spec.lua | 28 +++++++++---------
 8 files changed, 44 insertions(+), 38 deletions(-)

diff --git a/runtime/doc/msgpack_rpc.txt b/runtime/doc/msgpack_rpc.txt
index 571a08930c..b99b876722 100644
--- a/runtime/doc/msgpack_rpc.txt
+++ b/runtime/doc/msgpack_rpc.txt
@@ -286,7 +286,7 @@ nvim_buf_lines_event[{buf}, {changedtick}, {firstline}, {lastline}, {linedata},
     will be given as empty strings. 
 
     {more} is a boolean which tells you whether or not to expect more
-    |nvim_buf_updates| notifications for a single buffer change (i.e. Nvim has
+    |nvim_buf_lines_event| notifications for a single buffer change (i.e. Nvim has
     chunked up one event into several). Not yet used.
 
   Note: sometimes {changedtick} will be |v:null|, which means that the buffer
@@ -295,7 +295,7 @@ nvim_buf_lines_event[{buf}, {changedtick}, {firstline}, {lastline}, {linedata},
   doesn't reflect the actual buffer contents. Currently this behaviour is
   only used for the |inccommand| option.
 
-nvim_buf_changedtick_event[{buf}, {changedtick}]	 *nvim_buf_changedtick*
+nvim_buf_changedtick_event[{buf}, {changedtick}]  *nvim_buf_changedtick_event*
 
   Indicates that |b:changedtick| was incremented for the buffer {buf}, but no
   text was changed. This is currently only used by undo/redo.
@@ -304,7 +304,7 @@ nvim_buf_changedtick_event[{buf}, {changedtick}]	 *nvim_buf_changedtick*
 
     {changedtick} is the new value of |b:changedtick| for that buffer.
 
-nvim_buf_updates_end[{buf}]                                    		*nvim_buf_updates_end*
+nvim_buf_detach_event[{buf}]                           *nvim_buf_detach_event*
 
   Indicates that buffer updates for the nominated buffer have been disabled,
   either by calling |nvim_buf_detach| or because the buffer was unloaded
@@ -326,39 +326,45 @@ the buffer contents are unloaded from memory:
                                                        *buffer-updates-examples*
 Examples~
 
-If buffer updates are activated a new empty buffer (and sending the buffer's
+If buffer updates are activated on an empty buffer (and sending the buffer's
 content on the initial notification has been requested), the following
-|nvim_buf_updates_start| event will be sent: >
+|nvim_buf_lines_event| event will be sent: >
 
-  nvim_buf_updates_start[{buf}, [""], v:false]
+  nvim_buf_lines_event[{buf}, {changedtick}, 0, 0, [""], v:false]
 
 If the user adds 2 new lines to the start of a buffer, the following event
 would be generated: >
 
-  nvim_buf_update[{buf}, 0, 0, ["line1", "line2"]]
+  nvim_buf_lines_event[{buf}, {changedtick}, 0, 0, ["line1", "line2"], v:false]
 
 If the puts the cursor on a line containing the text `"Hello world"` and adds
 a `!` character to the end using insert mode, the following event would be
 generated: >
 
-  nvim_buf_update[{buf}, {linenr}, {linenr} + 1, ["Hello world!"]]
+  nvim_buf_lines_event[
+    {buf}, {changedtick}, {linenr}, {linenr} + 1,
+    ["Hello world!"], v:false
+  ]
 
 If the user moves their cursor to line 3 of a buffer and deletes 20 lines
 using `20dd`, the following event will be generated: >
 
-  nvim_buf_update[{buf}, 2, 20, []]
+  nvim_buf_lines_event[{buf}, {changedtick}, 2, 22, [], v:false]
 
 If the user selects lines 3-5 of a buffer using |linewise-visual| mode and
 then presses `p` to paste in a new block of 6 lines, then the following event
 would be sent to the co-process: >
 
-  nvim_buf_update[{buf}, 2, 5, ['pasted line 1', 'pasted
-  line 2', 'pasted line 3', 'pasted line 4', 'pasted line 5', 'pasted line
-  6']]
+  nvim_buf_lines_event[
+    {buf}, {changedtick}, 2, 5,
+    ['pasted line 1', 'pasted line 2', 'pasted line 3', 'pasted line 4',
+     'pasted line 5', 'pasted line 6'],
+    v:false
+  ]
 
 If the user uses :edit to reload a buffer then the following event would be
 generated: >
 
-  nvim_buf_updates_end[{buf}]
+  nvim_buf_detach_event[{buf}]
 
  vim:tw=78:ts=8:ft=help:norl:
diff --git a/src/nvim/buffer_updates.c b/src/nvim/buffer_updates.c
index 2852561ce0..4774b969c4 100644
--- a/src/nvim/buffer_updates.c
+++ b/src/nvim/buffer_updates.c
@@ -82,7 +82,7 @@ void buf_updates_send_end(buf_T *buf, uint64_t channelid)
     args.size = 1;
     args.items = xcalloc(sizeof(Object), args.size);
     args.items[0] = BUFFER_OBJ(buf->handle);
-    rpc_send_event(channelid, "nvim_buf_updates_end", args);
+    rpc_send_event(channelid, "nvim_buf_detach_event", args);
 }
 
 void buf_updates_unregister(buf_T *buf, uint64_t channelid)
diff --git a/src/nvim/ex_cmds.c b/src/nvim/ex_cmds.c
index 0638c10dc0..1d98f171b4 100644
--- a/src/nvim/ex_cmds.c
+++ b/src/nvim/ex_cmds.c
@@ -872,7 +872,7 @@ int do_move(linenr_T line1, linenr_T line2, linenr_T dest)
     changed_lines(dest + 1, 0, line1 + num_lines, 0L, false);
   }
 
-  // send nvim_buf_update regarding lines that were deleted
+  // send nvim_buf_lines_event regarding lines that were deleted
   if (kv_size(curbuf->update_channels)) {
     buf_updates_send_changes(curbuf, line1 + extra, 0, num_lines, true);
   }
diff --git a/src/nvim/fold.c b/src/nvim/fold.c
index 32ba665f64..b8ace511e8 100644
--- a/src/nvim/fold.c
+++ b/src/nvim/fold.c
@@ -746,7 +746,7 @@ deleteFold (
   if (last_lnum > 0) {
     changed_lines(first_lnum, (colnr_T)0, last_lnum, 0L, false);
 
-    // send one nvim_buf_update at the end
+    // send one nvim_buf_lines_event at the end
     if (kv_size(curbuf->update_channels)) {
       // last_lnum is the line *after* the last line of the outermost fold
       // that was modified. Note also that deleting a fold might only require
@@ -1608,7 +1608,7 @@ static void foldCreateMarkers(linenr_T start, linenr_T end)
   if (kv_size(curbuf->update_channels)) {
     // Note: foldAddMarker() may not actually change start and/or end if
     // u_save() is unable to save the buffer line, but we send the
-    // nvim_buf_update anyway since it won't do any harm.
+    // nvim_buf_lines_event anyway since it won't do any harm.
     int64_t num_changed = 1 + end - start;
     buf_updates_send_changes(curbuf, start, num_changed, num_changed, true);
   }
diff --git a/src/nvim/misc1.c b/src/nvim/misc1.c
index de68031135..6c5c47b91f 100644
--- a/src/nvim/misc1.c
+++ b/src/nvim/misc1.c
@@ -1921,9 +1921,9 @@ changed_lines(
     linenr_T lnume,       // line below last changed line
     long xtra,            // number of extra lines (negative when deleting)
     bool do_buf_event  // some callers like undo/redo call changed_lines()
-                      // and then increment b_changedtick *again*. This flag
-                      // allows these callers to send the nvim_buf_update events
-                      // after they're done modifying b_changedtick.
+                       // and then increment b_changedtick *again*. This flag
+                       // allows these callers to send the nvim_buf_lines_event
+                       // events after they're done modifying b_changedtick.
 )
 {
   changed_lines_buf(curbuf, lnum, lnume, xtra);
diff --git a/src/nvim/terminal.c b/src/nvim/terminal.c
index 9ab537d8b9..c29f0b3927 100644
--- a/src/nvim/terminal.c
+++ b/src/nvim/terminal.c
@@ -1234,7 +1234,7 @@ static void refresh_screen(Terminal *term, buf_T *buf)
 
   int change_start = row_to_linenr(term, term->invalid_start);
   int change_end = change_start + changed;
-  // Note: don't send nvim_buf_update event for a :terminal buffer
+  // Note: don't send nvim_buf_lines_event event for a :terminal buffer
   changed_lines(change_start, 0, change_end, added, false);
   term->invalid_start = INT_MAX;
   term->invalid_end = -1;
diff --git a/src/nvim/undo.c b/src/nvim/undo.c
index 985c6873a4..44bcefb332 100644
--- a/src/nvim/undo.c
+++ b/src/nvim/undo.c
@@ -1698,8 +1698,8 @@ bool u_undo_and_forget(int count)
     count = 1;
   }
   undo_undoes = true;
-  // don't send a nvim_buf_update for this undo is part of 'inccommand' playing
-  // with buffer contents
+  // don't send a nvim_buf_lines_event for this undo is part of 'inccommand'
+  // playing with buffer contents
   u_doit(count, true, false);
 
   if (curbuf->b_u_curhead == NULL) {
@@ -2284,7 +2284,7 @@ static void u_undoredo(int undo, bool do_buf_event)
   }
 
   // because the calls to changed()/unchanged() above will bump b_changedtick
-  // again, we need to send a nvim_buf_update with just the new value of
+  // again, we need to send a nvim_buf_lines_event with just the new value of
   // b:changedtick
   if (do_buf_event && kv_size(curbuf->update_channels)) {
     buf_updates_changedtick(curbuf);
diff --git a/test/functional/api/buffer_updates_spec.lua b/test/functional/api/buffer_updates_spec.lua
index 1bbba91187..cb5de4e206 100644
--- a/test/functional/api/buffer_updates_spec.lua
+++ b/test/functional/api/buffer_updates_spec.lua
@@ -54,7 +54,7 @@ end
 
 local function reopen(buf, expectedlines)
   ok(buffer('detach', buf))
-  expectn('nvim_buf_updates_end', {buf})
+  expectn('nvim_buf_detach_event', {buf})
   -- for some reason the :edit! increments tick by 2
   command('edit!')
   local tick = eval('b:changedtick')
@@ -157,7 +157,7 @@ describe('buffer events', function()
     -- create a new empty buffer and wipe out the old one ... this will
     -- turn off live updates
     command('enew!')
-    expectn('nvim_buf_updates_end', {b})
+    expectn('nvim_buf_detach_event', {b})
 
     -- add a line at the start of an empty file
     command('enew')
@@ -171,7 +171,7 @@ describe('buffer events', function()
 
     -- turn off live updates manually
     buffer('detach', b2)
-    expectn('nvim_buf_updates_end', {b2})
+    expectn('nvim_buf_detach_event', {b2})
 
     -- add multiple lines to a blank file
     command('enew!')
@@ -266,7 +266,7 @@ describe('buffer events', function()
     -- type text into the first line of a blank file, one character at a time
     command('enew!')
     tick = 2
-    expectn('nvim_buf_updates_end', {b})
+    expectn('nvim_buf_detach_event', {b})
     local bnew = nvim('get_current_buf')
     ok(buffer('attach', bnew, true))
     expectn('nvim_buf_lines_event', {bnew, tick, 0, -1, {''}, false})
@@ -386,7 +386,7 @@ describe('buffer events', function()
 
     -- reopen the file and watch live updates shut down
     command('edit')
-    expectn('nvim_buf_updates_end', {b})
+    expectn('nvim_buf_detach_event', {b})
   end)
 
   it('allows a channel to watch multiple buffers at once', function()
@@ -456,7 +456,7 @@ describe('buffer events', function()
     ok(buffer('detach', b))
     ok(buffer('detach', b))
     ok(buffer('detach', b))
-    expectn('nvim_buf_updates_end', {b})
+    expectn('nvim_buf_detach_event', {b})
     eval('rpcnotify('..channel..', "Hello Again")')
     expectn('Hello Again', {})
   end)
@@ -506,7 +506,7 @@ describe('buffer events', function()
 
     -- stop watching on channel 1
     ok(request(1, 'nvim_buf_detach', b))
-    wantn(1, 'nvim_buf_updates_end', {b})
+    wantn(1, 'nvim_buf_detach_event', {b})
 
     -- undo the change to buffer 1
     command('undo')
@@ -523,11 +523,11 @@ describe('buffer events', function()
     eval('rpcnotify('..channel1..', "Hello")')
     wantn(1, 'Hello', {})
 
-    -- close the buffer and channels 2 and 3 should get a nvim_buf_updates_end
+    -- close the buffer and channels 2 and 3 should get a nvim_buf_detach_event
     -- notification
     command('edit')
-    wantn(2, 'nvim_buf_updates_end', {b})
-    wantn(3, 'nvim_buf_updates_end', {b})
+    wantn(2, 'nvim_buf_detach_event', {b})
+    wantn(3, 'nvim_buf_detach_event', {b})
 
     -- make sure there are no other pending nvim_buf_lines_event messages going to
     -- channel 1
@@ -671,7 +671,7 @@ describe('buffer events', function()
 
     -- close our buffer by creating a new one
     command('enew')
-    expectn('nvim_buf_updates_end', {b})
+    expectn('nvim_buf_detach_event', {b})
 
     -- reopen the original buffer, make sure there are no Live Updates sent
     command('b1')
@@ -700,7 +700,7 @@ describe('buffer events', function()
     command('set hidden')
     command('enew')
 
-    -- note that no nvim_buf_updates_end is sent
+    -- note that no nvim_buf_detach_event is sent
     eval('rpcnotify('..channel..', "Hello There")')
     expectn('Hello There', {})
 
@@ -723,9 +723,9 @@ describe('buffer events', function()
       local b = open(true, {'AAA'})
 
       -- call :bunload or whatever the command is, and then check that we
-      -- receive a nvim_buf_updates_end
+      -- receive a nvim_buf_detach_event
       command(cmd)
-      expectn('nvim_buf_updates_end', {b})
+      expectn('nvim_buf_detach_event', {b})
     end
   end)
 

From 333679ad0ea6cb387debeae37645ecc0a830de25 Mon Sep 17 00:00:00 2001
From: KillTheMule <KillTheMule@users.noreply.github.com>
Date: Mon, 21 May 2018 20:42:59 +0200
Subject: [PATCH 25/26] Add empty options dict to buf_attach

---
 src/nvim/api/buffer.c                       |  9 +++++-
 test/functional/api/buffer_updates_spec.lua | 35 ++++++++++++---------
 2 files changed, 29 insertions(+), 15 deletions(-)

diff --git a/src/nvim/api/buffer.c b/src/nvim/api/buffer.c
index 12d1feb370..215859a499 100644
--- a/src/nvim/api/buffer.c
+++ b/src/nvim/api/buffer.c
@@ -83,15 +83,22 @@ String buffer_get_line(Buffer buffer, Integer index, Error *err)
 ///        the whole buffer. If so, the first notification will be a
 ///        `nvim_buf_lines_event`. Otherwise, the first notification will be
 ///        a `nvim_buf_changedtick_event`
+/// @param  opts  Optional parameters. Currently not used.
 /// @param[out] err Details of an error that may have occurred
 /// @return False when updates couldn't be enabled because the buffer isn't
-///         loaded; otherwise True.
+///         loaded or `opts` contained an invalid key; otherwise True.
 Boolean nvim_buf_attach(uint64_t channel_id,
                         Buffer buffer,
                         Boolean send_buffer,
+                        Dictionary opts,
                         Error *err)
   FUNC_API_SINCE(4) FUNC_API_REMOTE_ONLY
 {
+  if (opts.size > 0) {
+      api_set_error(err, kErrorTypeValidation, "dict isn't empty");
+      return false;
+  }
+
   buf_T *buf = find_buffer_by_handle(buffer, err);
 
   if (!buf) {
diff --git a/test/functional/api/buffer_updates_spec.lua b/test/functional/api/buffer_updates_spec.lua
index cb5de4e206..00409c1528 100644
--- a/test/functional/api/buffer_updates_spec.lua
+++ b/test/functional/api/buffer_updates_spec.lua
@@ -2,6 +2,7 @@ local helpers = require('test.functional.helpers')(after_each)
 local eq, ok = helpers.eq, helpers.ok
 local buffer, command, eval, nvim, next_msg = helpers.buffer,
   helpers.command, helpers.eval, helpers.nvim, helpers.next_msg
+local expect_err = helpers.expect_err
 
 local origlines = {"original line 1",
                    "original line 2",
@@ -36,7 +37,7 @@ local function open(activate, lines)
   -- arrive as expectected
   if activate then
     local firstline = 0
-    ok(buffer('attach', b, true))
+    ok(buffer('attach', b, true, {}))
     expectn('nvim_buf_lines_event', {b, tick, firstline, -1, lines, false})
   end
 
@@ -58,7 +59,7 @@ local function reopen(buf, expectedlines)
   -- for some reason the :edit! increments tick by 2
   command('edit!')
   local tick = eval('b:changedtick')
-  ok(buffer('attach', buf, true))
+  ok(buffer('attach', buf, true, {}))
   local firstline = 0
   expectn('nvim_buf_lines_event', {buf, tick, firstline, -1, expectedlines, false})
   command('normal! gg')
@@ -163,7 +164,7 @@ describe('buffer events', function()
     command('enew')
     tick = eval('b:changedtick')
     local b2 = nvim('get_current_buf')
-    ok(buffer('attach', b2, true))
+    ok(buffer('attach', b2, true, {}))
     expectn('nvim_buf_lines_event', {b2, tick, 0, -1, {""}, false})
     eval('append(0, ["new line 1"])')
     tick = tick + 1
@@ -176,7 +177,7 @@ describe('buffer events', function()
     -- add multiple lines to a blank file
     command('enew!')
     local b3 = nvim('get_current_buf')
-    ok(buffer('attach', b3, true))
+    ok(buffer('attach', b3, true, {}))
     tick = eval('b:changedtick')
     expectn('nvim_buf_lines_event', {b3, tick, 0, -1, {""}, false})
     eval('append(0, ["new line 1", "new line 2", "new line 3"])')
@@ -268,7 +269,7 @@ describe('buffer events', function()
     tick = 2
     expectn('nvim_buf_detach_event', {b})
     local bnew = nvim('get_current_buf')
-    ok(buffer('attach', bnew, true))
+    ok(buffer('attach', bnew, true, {}))
     expectn('nvim_buf_lines_event', {bnew, tick, 0, -1, {''}, false})
     sendkeys('i')
     sendkeys('h')
@@ -441,11 +442,11 @@ describe('buffer events', function()
     local b, tick = editoriginal(false)
 
     -- turn on live updates many times
-    ok(buffer('attach', b, true))
-    ok(buffer('attach', b, true))
-    ok(buffer('attach', b, true))
-    ok(buffer('attach', b, true))
-    ok(buffer('attach', b, true))
+    ok(buffer('attach', b, true, {}))
+    ok(buffer('attach', b, true, {}))
+    ok(buffer('attach', b, true, {}))
+    ok(buffer('attach', b, true, {}))
+    ok(buffer('attach', b, true, {}))
     expectn('nvim_buf_lines_event', {b, tick, 0, -1, origlines, false})
     eval('rpcnotify('..channel..', "Hello There")')
     expectn('Hello There', {})
@@ -490,9 +491,9 @@ describe('buffer events', function()
     local b, tick = open(false, lines)
 
     -- turn on live updates for sessions 1, 2 and 3
-    ok(request(1, 'nvim_buf_attach', b, true))
-    ok(request(2, 'nvim_buf_attach', b, true))
-    ok(request(3, 'nvim_buf_attach', b, true))
+    ok(request(1, 'nvim_buf_attach', b, true, {}))
+    ok(request(2, 'nvim_buf_attach', b, true, {}))
+    ok(request(3, 'nvim_buf_attach', b, true, {}))
     wantn(1, 'nvim_buf_lines_event', {b, tick, 0, -1, lines, false})
     wantn(2, 'nvim_buf_lines_event', {b, tick, 0, -1, lines, false})
     wantn(3, 'nvim_buf_lines_event', {b, tick, 0, -1, lines, false})
@@ -732,8 +733,14 @@ describe('buffer events', function()
   it('doesn\'t send the buffer\'s content when not requested', function()
     helpers.clear()
     local b, tick = editoriginal(false)
-    ok(buffer('attach', b, false))
+    ok(buffer('attach', b, false, {}))
     expectn('nvim_buf_changedtick_event', {b, tick})
   end)
 
+  it('returns a proper error on nonempty options dict', function()
+    helpers.clear()
+    local b = editoriginal(false)
+    expect_err("dict isn't empty", buffer, 'attach', b, false, {builtin="asfd"})
+  end)
+
 end)

From 2ca62239675b0c1e68b01aae1a0d45567b15e319 Mon Sep 17 00:00:00 2001
From: KillTheMule <KillTheMule@users.noreply.github.com>
Date: Mon, 21 May 2018 21:40:51 +0200
Subject: [PATCH 26/26] API: Accept empty lists as dictionaries

---
 src/nvim/generators/gen_api_dispatch.lua | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/nvim/generators/gen_api_dispatch.lua b/src/nvim/generators/gen_api_dispatch.lua
index 2ee1e5d4c5..15fcafb584 100644
--- a/src/nvim/generators/gen_api_dispatch.lua
+++ b/src/nvim/generators/gen_api_dispatch.lua
@@ -223,6 +223,11 @@ for i = 1, #functions do
           output:write('\n  } else if (args.items['..(j - 1)..'].type == kObjectTypeInteger && args.items['..(j - 1)..'].data.integer >= 0) {')
           output:write('\n    '..converted..' = (handle_T)args.items['..(j - 1)..'].data.integer;')
         end
+        -- accept empty lua tables as empty dictionarys
+        if rt:match('^Dictionary') then
+          output:write('\n  } else if (args.items['..(j - 1)..'].type == kObjectTypeArray && args.items['..(j - 1)..'].data.array.size == 0) {')
+          output:write('\n    '..converted..' = (Dictionary)ARRAY_DICT_INIT;')
+        end
         output:write('\n  } else {')
         output:write('\n    api_set_error(error, kErrorTypeException, "Wrong type for argument '..j..', expecting '..param[1]..'");')
         output:write('\n    goto cleanup;')