neovim
diff --git a/‎src/nvim/api/buffer.c
Copy file name to clipboard
+10-28Lines changed: 10 additions & 28 deletions b/‎src/nvim/api/buffer.c
Copy file name to clipboard
+10-28Lines changed: 10 additions & 28 deletions
diff --git a/‎src/nvim/buffer.c
Copy file name to clipboard
-1Lines changed: 0 additions & 1 deletion b/‎src/nvim/buffer.c
Copy file name to clipboard
-1Lines changed: 0 additions & 1 deletion
diff --git a/‎src/nvim/buffer_defs.h
Copy file name to clipboard
+1-6Lines changed: 1 addition & 6 deletions b/‎src/nvim/buffer_defs.h
Copy file name to clipboard
+1-6Lines changed: 1 addition & 6 deletions
diff --git a/‎src/nvim/decoration.c
Copy file name to clipboard
+50-25Lines changed: 50 additions & 25 deletions b/‎src/nvim/decoration.c
Copy file name to clipboard
+50-25Lines changed: 50 additions & 25 deletions
diff --git a/‎src/nvim/decoration.h
Copy file name to clipboard
+14-4Lines changed: 14 additions & 4 deletions b/‎src/nvim/decoration.h
Copy file name to clipboard
+14-4Lines changed: 14 additions & 4 deletions
diff --git a/‎src/nvim/extmark.c
Copy file name to clipboard
+15-21Lines changed: 15 additions & 21 deletions b/‎src/nvim/extmark.c
Copy file name to clipboard
+15-21Lines changed: 15 additions & 21 deletions
@@ -247,7 +247,6 @@ Boolean nvim_buf_detach(uint64_t channel_id, Buffer buffer, Error *err)
 }
 
 void nvim__buf_redraw_range(Buffer buffer, Integer first, Integer last, Error *err)
-  FUNC_API_LUA_ONLY
 {
   buf_T *buf = find_buffer_by_handle(buffer, err);
   if (!buf) {
@@ -1531,12 +1530,6 @@ Array nvim_buf_get_extmarks(Buffer buffer, Integer ns_id, Object start, Object e
 ///                   option is still used for hard tabs. By default lines are
 ///                   placed below the buffer line containing the mark.
 ///
-///                   Note: currently virtual lines are limited to one block
-///                   per buffer. Thus setting a new mark disables any previous
-///                   `virt_lines` decoration. However plugins should not rely
-///                   on this behaviour, as this limitation is planned to be
-///                   removed.
-///
 ///               - virt_lines_above: place virtual lines above instead.
 ///               - virt_lines_leftcol: Place extmarks in the leftmost
 ///                                     column of the window, bypassing
@@ -1680,9 +1673,8 @@ Integer nvim_buf_set_extmark(Buffer buffer, Integer ns_id, Integer line, Integer
     goto error;
   }
 
-  VirtLines virt_lines = KV_INITIAL_VALUE;
-  bool virt_lines_above = false;
   bool virt_lines_leftcol = false;
+  OPTION_TO_BOOL(virt_lines_leftcol, virt_lines_leftcol, false);
 
   if (opts->virt_lines.type == kObjectTypeArray) {
     Array a = opts->virt_lines.data.array;
@@ -1693,7 +1685,7 @@ Integer nvim_buf_set_extmark(Buffer buffer, Integer ns_id, Integer line, Integer
       }
       int dummig;
       VirtText jtem = parse_virt_text(a.items[j].data.array, err, &dummig);
-      kv_push(virt_lines, jtem);
+      kv_push(decor.virt_lines, ((struct virt_line){ jtem, virt_lines_leftcol }));
       if (ERROR_SET(err)) {
         goto error;
       }
@@ -1703,8 +1695,8 @@ Integer nvim_buf_set_extmark(Buffer buffer, Integer ns_id, Integer line, Integer
     goto error;
   }
 
-  OPTION_TO_BOOL(virt_lines_above, virt_lines_above, false);
-  OPTION_TO_BOOL(virt_lines_leftcol, virt_lines_leftcol, false);
+
+  OPTION_TO_BOOL(decor.virt_lines_above, virt_lines_above, false);
 
   if (opts->priority.type == kObjectTypeInteger) {
     Integer val = opts->priority.data.integer;
@@ -1774,7 +1766,7 @@ Integer nvim_buf_set_extmark(Buffer buffer, Integer ns_id, Integer line, Integer
 
   if (ephemeral) {
     d = &decor;
-  } else if (kv_size(decor.virt_text)
+  } else if (kv_size(decor.virt_text) || kv_size(decor.virt_lines)
              || decor.priority != DECOR_PRIORITY_BASE
              || decor.hl_eol) {
     // TODO(bfredl): this is a bit sketchy. eventually we should
@@ -1794,22 +1786,11 @@ Integer nvim_buf_set_extmark(Buffer buffer, Integer ns_id, Integer line, Integer
       goto error;
     }
 
-    if (kv_size(virt_lines) && buf->b_virt_line_mark) {
-      mtpos_t pos = marktree_lookup(buf->b_marktree, buf->b_virt_line_mark, NULL);
-      clear_virt_lines(buf, pos.row);  // handles pos.row == -1
-    }
+    extmark_set(buf, (uint64_t)ns_id, &id, (int)line, (colnr_T)col, line2, col2,
+                d, right_gravity, end_right_gravity, kExtmarkNoUndo);
 
-    uint64_t mark = extmark_set(buf, (uint64_t)ns_id, &id, (int)line, (colnr_T)col,
-                                line2, col2, d, right_gravity,
-                                end_right_gravity, kExtmarkNoUndo);
-
-    if (kv_size(virt_lines)) {
-      buf->b_virt_lines = virt_lines;
-      buf->b_virt_line_mark = mark;
-      buf->b_virt_line_pos = -1;
-      buf->b_virt_line_above = virt_lines_above;
-      buf->b_virt_line_leftcol = virt_lines_leftcol;
-      redraw_buf_line_later(buf, MIN(buf->b_ml.ml_line_count, line+1+(virt_lines_above?0:1)));
+    if (kv_size(decor.virt_lines)) {
+      redraw_buf_line_later(buf, MIN(buf->b_ml.ml_line_count, line+1+(decor.virt_lines_above?0:1)));
     }
   }
 
@@ -2013,6 +1994,7 @@ Dictionary nvim__buf_stats(Buffer buffer, Error *err)
   // this exists to debug issues
   PUT(rv, "dirty_bytes", INTEGER_OBJ((Integer)buf->deleted_bytes));
   PUT(rv, "dirty_bytes2", INTEGER_OBJ((Integer)buf->deleted_bytes2));
+  PUT(rv, "virt_blocks", INTEGER_OBJ((Integer)buf->b_virt_line_blocks));
 
   u_header_T *uhp = NULL;
   if (buf->b_u_curhead != NULL) {
 
@@ -818,7 +818,6 @@ static void free_buffer_stuff(buf_T *buf, int free_flags)
   uc_clear(&buf->b_ucmds);               // clear local user commands
   buf_delete_signs(buf, (char_u *)"*");  // delete any signs
   extmark_free_all(buf);                 // delete any extmarks
-  clear_virt_lines(buf, -1);
   map_clear_int(buf, MAP_ALL_MODES, true, false);    // clear local mappings
   map_clear_int(buf, MAP_ALL_MODES, true, true);     // clear local abbrevs
   XFREE_CLEAR(buf->b_start_fenc);
 
@@ -866,12 +866,7 @@ struct file_buffer {
   MarkTree b_marktree[1];
   Map(uint64_t, ExtmarkItem) b_extmark_index[1];
   Map(uint64_t, ExtmarkNs) b_extmark_ns[1];         // extmark namespaces
-
-  VirtLines b_virt_lines;
-  uint64_t b_virt_line_mark;
-  int b_virt_line_pos;
-  bool b_virt_line_above;
-  bool b_virt_line_leftcol;
+  size_t b_virt_line_blocks;    // number of virt_line blocks
 
   // array of channel_id:s which have asked to receive updates for this
   // buffer.
 
@@ -91,12 +91,31 @@ void decor_redraw(buf_T *buf, int row1, int row2, Decoration *decor)
   if (kv_size(decor->virt_text)) {
     redraw_buf_line_later(buf, row1+1);
   }
+
+  if (kv_size(decor->virt_lines)) {
+    redraw_buf_line_later(buf, MIN(buf->b_ml.ml_line_count,
+                                   row1+1+(decor->virt_lines_above?0:1)));
+  }
+}
+
+void decor_remove(buf_T *buf, int row, int row2, Decoration *decor)
+{
+  if (kv_size(decor->virt_lines)) {
+    assert(buf->b_virt_line_blocks > 0);
+    buf->b_virt_line_blocks--;
+  }
+  decor_redraw(buf, row, row2, decor);
+  decor_free(decor);
 }
 
 void decor_free(Decoration *decor)
 {
   if (decor && !decor->shared) {
     clear_virttext(&decor->virt_text);
+    for (size_t i = 0; i < kv_size(decor->virt_lines); i++) {
+      clear_virttext(&kv_A(decor->virt_lines, i).line);
+    }
+    kv_destroy(decor->virt_lines);
     xfree(decor);
   }
 }
@@ -118,7 +137,7 @@ Decoration *decor_find_virttext(buf_T *buf, int row, uint64_t ns_id)
     mtmark_t mark = marktree_itr_current(itr);
     if (mark.row < 0 || mark.row > row) {
       break;
-    } else if (mt_decor_level(mark.id) < 1) {
+    } else if (marktree_decor_level(mark.id) < kDecorLevelVisible) {
       goto next_mark;
     }
     ExtmarkItem *item = map_ref(uint64_t, ExtmarkItem)(buf->b_extmark_index,
@@ -162,7 +181,7 @@ bool decor_redraw_start(buf_T *buf, int top_row, DecorState *state)
       break;
     }
     if ((mark.row < top_row && mark.id&MARKTREE_END_FLAG)
-        || mt_decor_level(mark.id) < 1) {
+        || marktree_decor_level(mark.id) < kDecorLevelVisible) {
       goto next_mark;
     }
 
@@ -255,7 +274,8 @@ int decor_redraw_col(buf_T *buf, int col, int win_col, bool hidden, DecorState *
       break;
     }
 
-    if ((mark.id&MARKTREE_END_FLAG) || mt_decor_level(mark.id) < 1) {
+    if ((mark.id&MARKTREE_END_FLAG)
+        || marktree_decor_level(mark.id) < kDecorLevelVisible) {
       goto next_mark;
     }
 
@@ -417,33 +437,38 @@ void decor_free_all_mem(void)
 }
 
 
-int decor_virtual_lines(win_T *wp, linenr_T lnum)
+int decor_virt_lines(win_T *wp, linenr_T lnum, VirtLines *lines)
 {
   buf_T *buf = wp->w_buffer;
-  if (!buf->b_virt_line_mark) {
+  if (!buf->b_virt_line_blocks) {
+    // Only pay for what you use: in case virt_lines feature is not active
+    // in a buffer, plines do not need to access the marktree at all
     return 0;
   }
-  if (buf->b_virt_line_pos < 0) {
-    mtpos_t pos = marktree_lookup(buf->b_marktree, buf->b_virt_line_mark, NULL);
-    if (pos.row < 0) {
-      buf->b_virt_line_mark = 0;
+
+  int virt_lines = 0;
+  int row = (int)MAX(lnum - 2, 0);
+  int end_row = (int)lnum;
+  MarkTreeIter itr[1] = { 0 };
+  marktree_itr_get(buf->b_marktree, row, 0,  itr);
+  while (true) {
+    mtmark_t mark = marktree_itr_current(itr);
+    if (mark.row < 0 || mark.row >= end_row) {
+      break;
+    } else if (marktree_decor_level(mark.id) < kDecorLevelVirtLine) {
+      goto next_mark;
+    }
+    bool above = mark.row > (int)(lnum - 2);
+    ExtmarkItem *item = map_ref(uint64_t, ExtmarkItem)(buf->b_extmark_index, mark.id, false);
+    if (item && item->decor && item->decor->virt_lines_above == above) {
+      virt_lines += (int)kv_size(item->decor->virt_lines);
+      if (lines) {
+        kv_splice(*lines, item->decor->virt_lines);
+      }
     }
-    buf->b_virt_line_pos = pos.row + (buf->b_virt_line_above ? 0 : 1);
+next_mark:
+    marktree_itr_next(buf->b_marktree, itr);
   }
 
-  return (lnum-1 == buf->b_virt_line_pos) ? (int)kv_size(buf->b_virt_lines) : 0;
-}
-
-void clear_virt_lines(buf_T *buf, int row)
-{
-  if (row > -1) {
-    redraw_buf_line_later(buf, MIN(buf->b_ml.ml_line_count,
-                                   row+1+(buf->b_virt_line_above?0:1)));
-  }
-  for (size_t i = 0; i < kv_size(buf->b_virt_lines); i++) {
-    clear_virttext(&kv_A(buf->b_virt_lines, i));
-  }
-  kv_destroy(buf->b_virt_lines);  // re-initializes
-  buf->b_virt_line_pos = -1;
-  buf->b_virt_line_mark = 0;
+  return virt_lines;
 }
@@ -24,22 +24,34 @@ typedef enum {
   kHlModeBlend,
 } HlMode;
 
+typedef kvec_t(VirtTextChunk) VirtText;
+#define VIRTTEXT_EMPTY ((VirtText)KV_INITIAL_VALUE)
+
+
+typedef kvec_t(struct virt_line { VirtText line; bool left_col; }) VirtLines;
+
+
 struct Decoration
 {
   VirtText virt_text;
+  VirtLines virt_lines;
+
   int hl_id;  // highlight group
   VirtTextPos virt_text_pos;
   HlMode hl_mode;
+
+  // TODO(bfredl): at some point turn this into FLAGS
   bool virt_text_hide;
   bool hl_eol;
   bool shared;  // shared decoration, don't free
+  bool virt_lines_above;
   // TODO(bfredl): style, signs, etc
   DecorPriority priority;
   int col;  // fixed col value, like win_col
   int virt_text_width;  // width of virt_text
 };
-#define DECORATION_INIT { KV_INITIAL_VALUE, 0, kVTEndOfLine, kHlModeUnknown, \
-                          false, false, false, DECOR_PRIORITY_BASE, 0, 0 }
+#define DECORATION_INIT { KV_INITIAL_VALUE, KV_INITIAL_VALUE, 0, kVTEndOfLine, kHlModeUnknown, \
+                          false, false, false, false, DECOR_PRIORITY_BASE, 0, 0 }
 
 typedef struct {
   int start_row;
@@ -60,9 +72,7 @@ typedef struct {
   int row;
   int col_until;
   int current;
-
   int eol_col;
-  VirtText *virt_text;
 } DecorState;
 
 typedef struct {
 
@@ -83,8 +83,7 @@ uint64_t extmark_set(buf_T *buf, uint64_t ns_id, uint64_t *idp, int row, colnr_T
           ExtmarkItem it = map_del(uint64_t, ExtmarkItem)(buf->b_extmark_index,
                                                           old_mark);
           if (it.decor) {
-            decor_redraw(buf, row, row, it.decor);
-            decor_free(it.decor);
+            decor_remove(buf, row, row, it.decor);
           }
           mark = marktree_revise(buf->b_marktree, itr);
           goto revised;
@@ -96,7 +95,13 @@ uint64_t extmark_set(buf_T *buf, uint64_t ns_id, uint64_t *idp, int row, colnr_T
     }
   }
 
-  uint8_t decor_level = (decor != NULL) ? 1 : 0;
+  uint8_t decor_level = kDecorLevelNone;  // no decor
+  if (decor) {
+    decor_level = kDecorLevelVisible;  // decor affects redraw
+    if (kv_size(decor->virt_lines)) {
+      decor_level = kDecorLevelVirtLine;  // decor affects horizontal size
+    }
+  }
 
   if (end_row > -1) {
     mark = marktree_put_pair(buf->b_marktree,
@@ -119,6 +124,9 @@ uint64_t extmark_set(buf_T *buf, uint64_t ns_id, uint64_t *idp, int row, colnr_T
   }
 
   if (decor) {
+    if (kv_size(decor->virt_lines)) {
+      buf->b_virt_line_blocks++;
+    }
     decor_redraw(buf, row, end_row > -1 ? end_row : row, decor);
   }
 
@@ -172,12 +180,7 @@ bool extmark_del(buf_T *buf, uint64_t ns_id, uint64_t id)
   }
 
   if (item.decor) {
-    decor_redraw(buf, pos.row, pos2.row, item.decor);
-    decor_free(item.decor);
-  }
-
-  if (mark == buf->b_virt_line_mark) {
-    clear_virt_lines(buf, pos.row);
+    decor_remove(buf, pos.row, pos2.row, item.decor);
   }
 
   map_del(uint64_t, uint64_t)(ns->map, id);
@@ -230,17 +233,13 @@ bool extmark_clear(buf_T *buf, uint64_t ns_id, int l_row, colnr_T l_col, int u_r
       marktree_del_itr(buf->b_marktree, itr, false);
       if (*del_status >= 0) {  // we had a decor_id
         DecorItem it = kv_A(decors, *del_status);
-        decor_redraw(buf, it.row1, mark.row, it.decor);
-        decor_free(it.decor);
+        decor_remove(buf, it.row1, mark.row, it.decor);
       }
       map_del(uint64_t, ssize_t)(&delete_set, mark.id);
       continue;
     }
 
     uint64_t start_id = mark.id & ~MARKTREE_END_FLAG;
-    if (start_id == buf->b_virt_line_mark) {
-      clear_virt_lines(buf, mark.row);
-    }
     ExtmarkItem item = map_get(uint64_t, ExtmarkItem)(buf->b_extmark_index,
                                                       start_id);
 
@@ -259,8 +258,7 @@ bool extmark_clear(buf_T *buf, uint64_t ns_id, int l_row, colnr_T l_col, int u_r
         }
         map_put(uint64_t, ssize_t)(&delete_set, other, decor_id);
       } else if (item.decor) {
-        decor_redraw(buf, mark.row, mark.row, item.decor);
-        decor_free(item.decor);
+        decor_remove(buf, mark.row, mark.row, item.decor);
       }
       ExtmarkNs *my_ns = all_ns ? buf_ns_ref(buf, item.ns_id, false) : ns;
       map_del(uint64_t, uint64_t)(my_ns->map, item.mark_id);
@@ -278,8 +276,7 @@ bool extmark_clear(buf_T *buf, uint64_t ns_id, int l_row, colnr_T l_col, int u_r
     marktree_del_itr(buf->b_marktree, itr, false);
     if (decor_id >= 0) {
       DecorItem it = kv_A(decors, decor_id);
-      decor_redraw(buf, it.row1, pos.row, it.decor);
-      decor_free(it.decor);
+      decor_remove(buf, it.row1, pos.row, it.decor);
     }
   });
   map_clear(uint64_t, ssize_t)(&delete_set);
@@ -510,7 +507,6 @@ void extmark_apply_undo(ExtmarkUndoObject undo_info, bool undo)
                           kExtmarkNoUndo);
     }
   }
-  curbuf->b_virt_line_pos = -1;
 }
 
 
@@ -590,7 +586,6 @@ void extmark_splice_impl(buf_T *buf, int start_row, colnr_T start_col, bcount_t
                          colnr_T new_col, bcount_t new_byte, ExtmarkOp undo)
 {
   buf->deleted_bytes2 = 0;
-  buf->b_virt_line_pos = -1;
   buf_updates_send_splice(buf, start_row, start_col, start_byte,
                           old_row, old_col, old_byte,
                           new_row, new_col, new_byte);
@@ -682,7 +677,6 @@ void extmark_move_region(buf_T *buf, int start_row, colnr_T start_col, bcount_t
                          colnr_T new_col, bcount_t new_byte, ExtmarkOp undo)
 {
   buf->deleted_bytes2 = 0;
-  buf->b_virt_line_pos = -1;
   // TODO(bfredl): this is not synced to the buffer state inside the callback.
   // But unless we make the undo implementation smarter, this is not ensured
   // anyway.