folds: decrease reliance on global 'curwin'

TODO in a future commit:
- remains 2 instances of changed_lines that dont take into account
buffer

4 files changed, 116 insertions, 97 deletions

diff --git a/src/nvim/change.c b/src/nvim/change.c
index a341b8fce1..51afb40b40 100644
--- a/src/nvim/change.c
+++ b/src/nvim/change.c
@@ -361,8 +361,8 @@ void changed_bytes(linenr_T lnum, colnr_T col)
 
 /// insert/delete bytes at column
 ///
-/// Like changed_bytes() but also adjust extmark for "added" bytes.
-/// When "added" is negative text was deleted.
+/// Like changed_bytes() but also adjust extmark for "new" bytes.
+/// When "new" is negative text was deleted.
 static void inserted_bytes(linenr_T lnum, colnr_T col, int old, int new)
 {
   if (curbuf_splice_pending == 0) {
diff --git a/src/nvim/ex_cmds.c b/src/nvim/ex_cmds.c
index 1cd95f2ed9..d26d3387f8 100644
--- a/src/nvim/ex_cmds.c
+++ b/src/nvim/ex_cmds.c
@@ -882,7 +882,7 @@ int do_move(linenr_T line1, linenr_T line2, linenr_T dest)
     mark_adjust_nofold(line2 + 1, dest, -num_lines, 0L, kExtmarkNOOP);
     FOR_ALL_TAB_WINDOWS(tab, win) {
       if (win->w_buffer == curbuf) {
-        foldMoveRange(&win->w_folds, line1, line2, dest);
+        foldMoveRange(win, &win->w_folds, line1, line2, dest);
       }
     }
     curbuf->b_op_start.lnum = dest - num_lines + 1;
@@ -891,7 +891,7 @@ int do_move(linenr_T line1, linenr_T line2, linenr_T dest)
     mark_adjust_nofold(dest + 1, line1 - 1, num_lines, 0L, kExtmarkNOOP);
     FOR_ALL_TAB_WINDOWS(tab, win) {
       if (win->w_buffer == curbuf) {
-        foldMoveRange(&win->w_folds, dest + 1, line1 - 1, line2);
+        foldMoveRange(win, &win->w_folds, dest + 1, line1 - 1, line2);
       }
     }
     curbuf->b_op_start.lnum = dest + 1;
diff --git a/src/nvim/fold.c b/src/nvim/fold.c
index 405f15d751..08f43dff9a 100644
--- a/src/nvim/fold.c
+++ b/src/nvim/fold.c
@@ -642,15 +642,17 @@ void foldCreate(win_T *wp, linenr_T start, linenr_T end)
     /* We want the new fold to be closed.  If it would remain open because
      * of using 'foldlevel', need to adjust fd_flags of containing folds.
      */
-    if (use_level && !closed && level < curwin->w_p_fdl)
+    if (use_level && !closed && level < wp->w_p_fdl) {
       closeFold(start, 1L);
-    if (!use_level)
-      curwin->w_fold_manual = true;
+    }
+    if (!use_level) {
+      wp->w_fold_manual = true;
+    }
     fp->fd_flags = FD_CLOSED;
     fp->fd_small = kNone;
 
     /* redraw */
-    changed_window_setting();
+    changed_window_setting_win(wp);
   }
 }
 
@@ -711,7 +713,7 @@ void deleteFold(
       lnum = found_fp->fd_top + found_fp->fd_len + found_off;
 
       if (foldmethodIsManual(wp)) {
-        deleteFoldEntry(found_ga,
+        deleteFoldEntry(wp, found_ga,
                         (int)(found_fp - (fold_T *)found_ga->ga_data),
                         recursive);
       } else {
@@ -724,22 +726,24 @@ void deleteFold(
         if (!did_one) {
           parseMarker(wp);
         }
-        deleteFoldMarkers(found_fp, recursive, found_off);
+        deleteFoldMarkers(wp, found_fp, recursive, found_off);
       }
       did_one = true;
 
       /* redraw window */
-      changed_window_setting();
+      changed_window_setting_win(wp);
     }
   }
   if (!did_one) {
     EMSG(_(e_nofold));
     /* Force a redraw to remove the Visual highlighting. */
-    if (had_visual)
-      redraw_curbuf_later(INVERTED);
-  } else
-    /* Deleting markers may make cursor column invalid. */
-    check_cursor_col();
+    if (had_visual) {
+      redraw_buf_later(wp->w_buffer, INVERTED);
+    }
+  } else {
+    // Deleting markers may make cursor column invalid
+    check_cursor_col_win(wp);
+  }
 
   if (last_lnum > 0) {
     // TODO(teto): pass the buffer
@@ -751,7 +755,7 @@ void 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;
-    buf_updates_send_changes(curbuf, first_lnum, num_changed,
+    buf_updates_send_changes(wp->w_buffer, first_lnum, num_changed,
                              num_changed, true);
   }
 }
@@ -1303,7 +1307,7 @@ static void foldOpenNested(fold_T *fpr)
 // Delete fold "idx" from growarray "gap".
 // When "recursive" is true also delete all the folds contained in it.
 // When "recursive" is false contained folds are moved one level up.
-static void deleteFoldEntry(garray_T *const gap, const int idx,
+static void deleteFoldEntry(win_T *const wp, garray_T *const gap, const int idx,
                             const bool recursive)
 {
   fold_T *fp = (fold_T *)gap->ga_data + idx;
@@ -1371,11 +1375,11 @@ void foldMarkAdjust(win_T *wp, linenr_T line1, linenr_T line2, long amount, long
    * just above the line. */
   if ((State & INSERT) && amount == (linenr_T)1 && line2 == MAXLNUM)
     --line1;
-  foldMarkAdjustRecurse(&wp->w_folds, line1, line2, amount, amount_after);
+  foldMarkAdjustRecurse(wp, &wp->w_folds, line1, line2, amount, amount_after);
 }
 
 /* foldMarkAdjustRecurse() {{{2 */
-static void foldMarkAdjustRecurse(garray_T *gap, linenr_T line1, linenr_T line2, long amount, long amount_after)
+static void foldMarkAdjustRecurse(win_T *wp, garray_T *gap, linenr_T line1, linenr_T line2, long amount, long amount_after)
 {
   fold_T      *fp;
   linenr_T last;
@@ -1423,7 +1427,7 @@ static void foldMarkAdjustRecurse(garray_T *gap, linenr_T line1, linenr_T line2,
         // 4. fold completely contained in range
         if (amount == MAXLNUM) {
           // Deleting lines: delete the fold completely
-          deleteFoldEntry(gap, i, true);
+          deleteFoldEntry(wp, gap, i, true);
           i--;              // adjust index for deletion
           fp--;
         } else {
@@ -1432,7 +1436,7 @@ static void foldMarkAdjustRecurse(garray_T *gap, linenr_T line1, linenr_T line2,
       } else {
         if (fp->fd_top < top) {
           /* 2 or 3: need to correct nested folds too */
-          foldMarkAdjustRecurse(&fp->fd_nested, line1 - fp->fd_top,
+          foldMarkAdjustRecurse(wp, &fp->fd_nested, line1 - fp->fd_top,
               line2 - fp->fd_top, amount, amount_after);
           if (last <= line2) {
             /* 2. fold contains line1, line2 is below fold */
@@ -1448,13 +1452,13 @@ static void foldMarkAdjustRecurse(garray_T *gap, linenr_T line1, linenr_T line2,
           /* 5. fold is below line1 and contains line2; need to
            * correct nested folds too */
           if (amount == MAXLNUM) {
-            foldMarkAdjustRecurse(&fp->fd_nested, line1 - fp->fd_top,
+            foldMarkAdjustRecurse(wp, &fp->fd_nested, line1 - fp->fd_top,
                                   line2 - fp->fd_top, amount,
                                   amount_after + (fp->fd_top - top));
             fp->fd_len -= line2 - fp->fd_top + 1;
             fp->fd_top = line1;
           } else {
-            foldMarkAdjustRecurse(&fp->fd_nested, line1 - fp->fd_top,
+            foldMarkAdjustRecurse(wp, &fp->fd_nested, line1 - fp->fd_top,
                                   line2 - fp->fd_top, amount,
                                   amount_after - amount);
             fp->fd_len += amount_after - amount;
@@ -1497,16 +1501,18 @@ static int getDeepestNestingRecurse(garray_T *gap)
 /// Check if a fold is closed and update the info needed to check nested folds.
 ///
 /// @param[in,out] use_levelp true: outer fold had FD_LEVEL
+/// @param[in,out] fp fold to check
 /// @param level folding depth
-/// @param[out] maybe_smallp TRUE: outer this had fd_small == kNone
+/// @param[out] maybe_smallp true: outer this had fd_small == kNone
 /// @param lnum_off line number offset for fp->fd_top
+/// @return true if fold is closed
 static bool check_closed(
     win_T *const wp,
     fold_T *const fp,
-    bool *const use_levelp,     // true: outer fold had FD_LEVEL
-    const int level,            // folding depth
-    bool *const maybe_smallp,   // true: outer this had fd_small == kNone
-    const linenr_T lnum_off     // line number offset for fp->fd_top
+    bool *const use_levelp,
+    const int level,
+    bool *const maybe_smallp,
+    const linenr_T lnum_off
 )
 {
   bool closed = false;
@@ -1552,13 +1558,13 @@ checkSmall(
     // Mark any nested folds to maybe-small
     setSmallMaybe(&fp->fd_nested);
 
-    if (fp->fd_len > curwin->w_p_fml) {
+    if (fp->fd_len > wp->w_p_fml) {
       fp->fd_small = kFalse;
     } else {
       int count = 0;
       for (int n = 0; n < fp->fd_len; n++) {
         count += plines_win_nofold(wp, fp->fd_top + lnum_off + n);
-        if (count > curwin->w_p_fml) {
+        if (count > wp->w_p_fml) {
           fp->fd_small = kFalse;
           return;
         }
@@ -1604,7 +1610,7 @@ static void foldCreateMarkers(win_T *wp, linenr_T start, linenr_T end)
   // u_save() is unable to save the buffer line, but we send the
   // 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);
+  buf_updates_send_changes(buf, start, num_changed, num_changed, true);
 }
 
 /* foldAddMarker() {{{2 */
@@ -1621,7 +1627,7 @@ static void foldAddMarker(
   bool line_is_comment = false;
 
   // Allocate a new line: old-line + 'cms'-start + marker + 'cms'-end
-  line = ml_get(lnum);
+  line = ml_get_buf(buf, lnum, false);
   size_t line_len = STRLEN(line);
   size_t added = 0;
 
@@ -1640,7 +1646,7 @@ static void foldAddMarker(
       STRCPY(newline + line_len + (p - cms) + markerlen, p + 2);
       added = markerlen + STRLEN(cms)-2;
     }
-    ml_replace(lnum, newline, false);
+    ml_replace_buf(buf, lnum, newline, false);
     if (added) {
       extmark_splice(buf, (int)lnum-1, (int)line_len,
                      0, 0,
@@ -1655,6 +1661,7 @@ static void foldAddMarker(
  */
 static void
 deleteFoldMarkers(
+    win_T *wp,
     fold_T *fp,
     int recursive,
     linenr_T lnum_off             // offset for fp->fd_top
@@ -1662,12 +1669,12 @@ deleteFoldMarkers(
 {
   if (recursive) {
     for (int i = 0; i < fp->fd_nested.ga_len; ++i) {
-      deleteFoldMarkers((fold_T *)fp->fd_nested.ga_data + i, TRUE,
+      deleteFoldMarkers(wp, (fold_T *)fp->fd_nested.ga_data + i, TRUE,
                         lnum_off + fp->fd_top);
     }
   }
-  foldDelMarker(fp->fd_top + lnum_off, curwin->w_p_fmr, foldstartmarkerlen);
-  foldDelMarker(fp->fd_top + lnum_off + fp->fd_len - 1, foldendmarker,
+  foldDelMarker(wp->w_buffer, fp->fd_top + lnum_off, wp->w_p_fmr, foldstartmarkerlen);
+  foldDelMarker(wp->w_buffer, fp->fd_top + lnum_off + fp->fd_len - 1, foldendmarker,
                 foldendmarkerlen);
 }
 
@@ -1677,17 +1684,17 @@ deleteFoldMarkers(
 // Delete 'commentstring' if it matches.
 // If the marker is not found, there is no error message.  Could be a missing
 // close-marker.
-static void foldDelMarker(linenr_T lnum, char_u *marker, size_t markerlen)
+static void foldDelMarker(buf_T *buf, linenr_T lnum, char_u *marker, size_t markerlen)
 {
   char_u      *newline;
-  char_u      *cms = curbuf->b_p_cms;
+  char_u      *cms = buf->b_p_cms;
   char_u      *cms2;
 
   // end marker may be missing and fold extends below the last line
-  if (lnum > curbuf->b_ml.ml_line_count) {
+  if (lnum > buf->b_ml.ml_line_count) {
     return;
   }
-  char_u *line = ml_get(lnum);
+  char_u *line = ml_get_buf(buf, lnum, false);
   for (char_u *p = line; *p != NUL; ++p) {
     if (STRNCMP(p, marker, markerlen) != 0) {
       continue;
@@ -1712,8 +1719,8 @@ static void foldDelMarker(linenr_T lnum, char_u *marker, size_t markerlen)
       assert(p >= line);
       memcpy(newline, line, (size_t)(p - line));
       STRCPY(newline + (p - line), p + len);
-      ml_replace(lnum, newline, false);
-      extmark_splice(curbuf, (int)lnum-1, (int)(p - line),
+      ml_replace_buf(buf, lnum, newline, false);
+      extmark_splice(buf, (int)lnum-1, (int)(p - line),
                      0, (int)len,
                      0, 0, kExtmarkUndo);
     }
@@ -1903,13 +1910,12 @@ void foldtext_cleanup(char_u *str)
 /* foldUpdateIEMS() {{{2 */
 /*
  * Update the folding for window "wp", at least from lines "top" to "bot".
- * Return TRUE if any folds did change.
  * IEMS = "Indent Expr Marker Syntax"
  */
 static void foldUpdateIEMS(win_T *const wp, linenr_T top, linenr_T bot)
 {
   fline_T fline;
-  void        (*getlevel)(fline_T *);
+  LevelGetter getlevel = NULL;
   fold_T      *fp;
 
   /* Avoid problems when being called recursively. */
@@ -2092,7 +2098,7 @@ static void foldUpdateIEMS(win_T *const wp, linenr_T top, linenr_T bot)
   }
 
   /* There can't be any folds from start until end now. */
-  foldRemove(&wp->w_folds, start, end);
+  foldRemove(wp, &wp->w_folds, start, end);
 
   /* If some fold changed, need to redraw and position cursor. */
   if (fold_changed && wp->w_p_fen)
@@ -2272,12 +2278,12 @@ static linenr_T foldUpdateIEMSRecurse(
               if (fp->fd_top > firstlnum) {
                 // We will move the start of this fold up, hence we move all
                 // nested folds (with relative line numbers) down.
-                foldMarkAdjustRecurse(&fp->fd_nested,
+                foldMarkAdjustRecurse(flp->wp, &fp->fd_nested,
                                       (linenr_T)0, (linenr_T)MAXLNUM,
                                       (long)(fp->fd_top - firstlnum), 0L);
               } else {
                 // Will move fold down, move nested folds relatively up.
-                foldMarkAdjustRecurse(&fp->fd_nested,
+                foldMarkAdjustRecurse(flp->wp, &fp->fd_nested,
                                       (linenr_T)0,
                                       (long)(firstlnum - fp->fd_top - 1),
                                       (linenr_T)MAXLNUM,
@@ -2307,10 +2313,10 @@ static linenr_T foldUpdateIEMSRecurse(
                 breakstart = flp->lnum;
                 breakend = flp->lnum;
               }
-              foldRemove(&fp->fd_nested, breakstart - fp->fd_top,
+              foldRemove(flp->wp, &fp->fd_nested, breakstart - fp->fd_top,
                          breakend - fp->fd_top);
               i = (int)(fp - (fold_T *)gap->ga_data);
-              foldSplit(gap, i, breakstart, breakend - 1);
+              foldSplit(flp->wp->w_buffer, gap, i, breakstart, breakend - 1);
               fp = (fold_T *)gap->ga_data + i + 1;
               /* If using the "marker" or "syntax" method, we
                * need to continue until the end of the fold is
@@ -2326,7 +2332,7 @@ static linenr_T foldUpdateIEMSRecurse(
               if (i != 0) {
                 fp2 = fp - 1;
                 if (fp2->fd_top + fp2->fd_len == fp->fd_top) {
-                  foldMerge(fp2, gap, fp);
+                  foldMerge(flp->wp, fp2, gap, fp);
                   fp = fp2;
                 }
               }
@@ -2337,12 +2343,12 @@ static linenr_T foldUpdateIEMSRecurse(
             // A fold that starts at or after startlnum and stops
             // before the new fold must be deleted.  Continue
             // looking for the next one.
-            deleteFoldEntry(gap, (int)(fp - (fold_T *)gap->ga_data), true);
+            deleteFoldEntry(flp->wp, gap, (int)(fp - (fold_T *)gap->ga_data), true);
           } else {
             /* A fold has some lines above startlnum, truncate it
              * to stop just above startlnum.  */
             fp->fd_len = startlnum - fp->fd_top;
-            foldMarkAdjustRecurse(&fp->fd_nested,
+            foldMarkAdjustRecurse(flp->wp, &fp->fd_nested,
                                   (linenr_T)fp->fd_len, (linenr_T)MAXLNUM,
                                   (linenr_T)MAXLNUM, 0L);
             fold_changed = true;
@@ -2471,7 +2477,7 @@ static linenr_T foldUpdateIEMSRecurse(
 
   // Delete contained folds from the end of the last one found until where
   // we stopped looking.
-  foldRemove(&fp->fd_nested, startlnum2 - fp->fd_top,
+  foldRemove(flp->wp, &fp->fd_nested, startlnum2 - fp->fd_top,
       flp->lnum - 1 - fp->fd_top);
 
   if (lvl < level) {
@@ -2490,7 +2496,7 @@ static linenr_T foldUpdateIEMSRecurse(
           // indent or expr method: split fold to create a new one
           // below bot
           i = (int)(fp - (fold_T *)gap->ga_data);
-          foldSplit(gap, i, flp->lnum, bot);
+          foldSplit(flp->wp->w_buffer, gap, i, flp->lnum, bot);
           fp = (fold_T *)gap->ga_data + i;
         }
       } else {
@@ -2509,7 +2515,7 @@ static linenr_T foldUpdateIEMSRecurse(
     if (fp2->fd_top + fp2->fd_len > flp->lnum) {
       if (fp2->fd_top < flp->lnum) {
         /* Make fold that includes lnum start at lnum. */
-        foldMarkAdjustRecurse(&fp2->fd_nested,
+        foldMarkAdjustRecurse(flp->wp, &fp2->fd_nested,
             (linenr_T)0, (long)(flp->lnum - fp2->fd_top - 1),
             (linenr_T)MAXLNUM, (long)(fp2->fd_top - flp->lnum));
         fp2->fd_len -= flp->lnum - fp2->fd_top;
@@ -2519,12 +2525,12 @@ static linenr_T foldUpdateIEMSRecurse(
 
       if (lvl >= level) {
         /* merge new fold with existing fold that follows */
-        foldMerge(fp, gap, fp2);
+        foldMerge(flp->wp, fp, gap, fp2);
       }
       break;
     }
     fold_changed = true;
-    deleteFoldEntry(gap, (int)(fp2 - (fold_T *)gap->ga_data), true);
+    deleteFoldEntry(flp->wp, gap, (int)(fp2 - (fold_T *)gap->ga_data), true);
   }
 
   /* Need to redraw the lines we inspected, which might be further down than
@@ -2560,8 +2566,10 @@ static void foldInsert(garray_T *gap, int i)
  * The caller must first have taken care of any nested folds from "top" to
  * "bot"!
  */
-static void foldSplit(garray_T *const gap, const int i, const linenr_T top,
-                      const linenr_T bot)
+static void foldSplit(buf_T *buf, garray_T *const gap,
+                      const int i, const linenr_T top,
+                      const linenr_T bot
+                      )
 {
   fold_T      *fp2;
 
@@ -2616,7 +2624,7 @@ static void foldSplit(garray_T *const gap, const int i, const linenr_T top,
  * 5: made to start below "bot".
  * 6: not changed
  */
-static void foldRemove(garray_T *gap, linenr_T top, linenr_T bot)
+static void foldRemove(win_T *const wp, garray_T *gap, linenr_T top, linenr_T bot)
 {
   fold_T      *fp = NULL;
 
@@ -2628,10 +2636,10 @@ static void foldRemove(garray_T *gap, linenr_T top, linenr_T bot)
     // Find fold that includes top or a following one.
     if (foldFind(gap, top, &fp) && fp->fd_top < top) {
       // 2: or 3: need to delete nested folds
-      foldRemove(&fp->fd_nested, top - fp->fd_top, bot - fp->fd_top);
+      foldRemove(wp, &fp->fd_nested, top - fp->fd_top, bot - fp->fd_top);
       if (fp->fd_top + fp->fd_len - 1 > bot) {
         // 3: need to split it.
-        foldSplit(gap, (int)(fp - (fold_T *)gap->ga_data), top, bot);
+        foldSplit(wp->w_buffer, gap, (int)(fp - (fold_T *)gap->ga_data), top, bot);
       } else {
         // 2: truncate fold at "top".
         fp->fd_len = top - fp->fd_top;
@@ -2649,7 +2657,7 @@ static void foldRemove(garray_T *gap, linenr_T top, linenr_T bot)
       fold_changed = true;
       if (fp->fd_top + fp->fd_len - 1 > bot) {
         // 5: Make fold that includes bot start below bot.
-        foldMarkAdjustRecurse(&fp->fd_nested,
+        foldMarkAdjustRecurse(wp, &fp->fd_nested,
             (linenr_T)0, (long)(bot - fp->fd_top),
             (linenr_T)MAXLNUM, (long)(fp->fd_top - bot - 1));
         fp->fd_len -= bot - fp->fd_top + 1;
@@ -2658,7 +2666,7 @@ static void foldRemove(garray_T *gap, linenr_T top, linenr_T bot)
       }
 
       // 4: Delete completely contained fold.
-      deleteFoldEntry(gap, (int)(fp - (fold_T *)gap->ga_data), true);
+      deleteFoldEntry(wp, gap, (int)(fp - (fold_T *)gap->ga_data), true);
     }
   }
 }
@@ -2710,18 +2718,18 @@ static void foldReverseOrder(
 // 8. truncated below dest and shifted up.
 // 9. shifted up
 // 10. not changed
-static void truncate_fold(fold_T *fp, linenr_T end)
+static void truncate_fold(win_T *const wp, fold_T *fp, linenr_T end)
 {
   // I want to stop *at here*, foldRemove() stops *above* top
   end += 1;
-  foldRemove(&fp->fd_nested, end - fp->fd_top, MAXLNUM);
+  foldRemove(wp, &fp->fd_nested, end - fp->fd_top, MAXLNUM);
   fp->fd_len = end - fp->fd_top;
 }
 
 #define FOLD_END(fp) ((fp)->fd_top + (fp)->fd_len - 1)
 #define VALID_FOLD(fp, gap) ((fp) < ((fold_T *)(gap)->ga_data + (gap)->ga_len))
 #define FOLD_INDEX(fp, gap) ((size_t)(fp - ((fold_T *)(gap)->ga_data)))
-void foldMoveRange(garray_T *gap, const linenr_T line1, const linenr_T line2,
+void foldMoveRange(win_T *const wp, garray_T *gap, const linenr_T line1, const linenr_T line2,
                    const linenr_T dest)
 {
   fold_T *fp;
@@ -2733,20 +2741,20 @@ void foldMoveRange(garray_T *gap, const linenr_T line1, const linenr_T line2,
     if (FOLD_END(fp) > dest) {
       // Case 4 -- don't have to change this fold, but have to move nested
       // folds.
-      foldMoveRange(&fp->fd_nested, line1 - fp->fd_top, line2 -
+      foldMoveRange(wp, &fp->fd_nested, line1 - fp->fd_top, line2 -
                     fp->fd_top, dest - fp->fd_top);
       return;
     } else if (FOLD_END(fp) > line2) {
       // Case 3 -- Remove nested folds between line1 and line2 & reduce the
       // length of fold by "range_len".
       // Folds after this one must be dealt with.
-      foldMarkAdjustRecurse(&fp->fd_nested, line1 - fp->fd_top,
+      foldMarkAdjustRecurse(wp, &fp->fd_nested, line1 - fp->fd_top,
                             line2 - fp->fd_top, MAXLNUM, -range_len);
       fp->fd_len -= range_len;
     } else {
       // Case 2 -- truncate fold *above* line1.
       // Folds after this one must be dealt with.
-      truncate_fold(fp, line1 - 1);
+      truncate_fold(wp, fp, line1 - 1);
     }
     // Look at the next fold, and treat that one as if it were the first after
     // "line1" (because now it is).
@@ -2764,13 +2772,13 @@ void foldMoveRange(garray_T *gap, const linenr_T line1, const linenr_T line2,
     }
     if (VALID_FOLD(fp, gap) && fp->fd_top <= dest) {
       // Case 8. -- ensure truncated at dest, shift up
-      truncate_fold(fp, dest);
+      truncate_fold(wp, fp, dest);
       fp->fd_top -= range_len;
     }
     return;
   } else if (FOLD_END(fp) > dest) {
     // Case 7 -- remove nested folds and shrink
-    foldMarkAdjustRecurse(&fp->fd_nested, line2 + 1 - fp->fd_top,
+    foldMarkAdjustRecurse(wp, &fp->fd_nested, line2 + 1 - fp->fd_top,
                           dest - fp->fd_top, MAXLNUM, -move_len);
     fp->fd_len -= move_len;
     fp->fd_top += move_len;
@@ -2786,7 +2794,7 @@ void foldMoveRange(garray_T *gap, const linenr_T line1, const linenr_T line2,
       // 5, or 6
       if (FOLD_END(fp) > line2) {
         // 6, truncate before moving
-        truncate_fold(fp, line2);
+        truncate_fold(wp, fp, line2);
       }
       fp->fd_top += move_len;
       continue;
@@ -2798,7 +2806,7 @@ void foldMoveRange(garray_T *gap, const linenr_T line1, const linenr_T line2,
     }
 
     if (FOLD_END(fp) > dest) {
-      truncate_fold(fp, dest);
+      truncate_fold(wp, fp, dest);
     }
 
     fp->fd_top -= range_len;
@@ -2830,7 +2838,7 @@ void foldMoveRange(garray_T *gap, const linenr_T line1, const linenr_T line2,
  * The resulting fold is "fp1", nested folds are moved from "fp2" to "fp1".
  * Fold entry "fp2" in "gap" is deleted.
  */
-static void foldMerge(fold_T *fp1, garray_T *gap, fold_T *fp2)
+static void foldMerge(win_T *const wp, fold_T *fp1, garray_T *gap, fold_T *fp2)
 {
   fold_T      *fp3;
   fold_T      *fp4;
@@ -2841,7 +2849,7 @@ static void foldMerge(fold_T *fp1, garray_T *gap, fold_T *fp2)
   /* If the last nested fold in fp1 touches the first nested fold in fp2,
    * merge them recursively. */
   if (foldFind(gap1, fp1->fd_len - 1L, &fp3) && foldFind(gap2, 0L, &fp4))
-    foldMerge(fp3, gap2, fp4);
+    foldMerge(wp, fp3, gap2, fp4);
 
   /* Move nested folds in fp2 to the end of fp1. */
   if (!GA_EMPTY(gap2)) {
@@ -2856,7 +2864,7 @@ static void foldMerge(fold_T *fp1, garray_T *gap, fold_T *fp2)
   }
 
   fp1->fd_len += fp2->fd_len;
-  deleteFoldEntry(gap, (int)(fp2 - (fold_T *)gap->ga_data), true);
+  deleteFoldEntry(wp, gap, (int)(fp2 - (fold_T *)gap->ga_data), true);
   fold_changed = true;
 }
 
diff --git a/src/nvim/memline.c b/src/nvim/memline.c
index b695d0e139..8c66154b6f 100644
--- a/src/nvim/memline.c
+++ b/src/nvim/memline.c
@@ -2390,21 +2390,32 @@ static int ml_append_int(
 
 void ml_add_deleted_len(char_u *ptr, ssize_t len)
 {
+  ml_add_deleted_len_buf(curbuf, ptr, len);
+}
+
+void ml_add_deleted_len_buf(buf_T *buf, char_u *ptr, ssize_t len)
+{
   if (inhibit_delete_count) {
     return;
   }
   if (len == -1) {
     len = STRLEN(ptr);
   }
-  curbuf->deleted_bytes += len+1;
-  if (curbuf->update_need_codepoints) {
-    mb_utflen(ptr, len, &curbuf->deleted_codepoints,
-              &curbuf->deleted_codeunits);
-    curbuf->deleted_codepoints++;  // NL char
-    curbuf->deleted_codeunits++;
+  buf->deleted_bytes += len+1;
+  if (buf->update_need_codepoints) {
+    mb_utflen(ptr, len, &buf->deleted_codepoints,
+              &buf->deleted_codeunits);
+    buf->deleted_codepoints++;  // NL char
+    buf->deleted_codeunits++;
   }
 }
 
+
+int ml_replace(linenr_T lnum, char_u *line, bool copy)
+{
+  return ml_replace_buf(curbuf, lnum, line, copy);
+}
+
 /*
  * Replace line lnum, with buffering, in current buffer.
  *
@@ -2416,13 +2427,13 @@ void ml_add_deleted_len(char_u *ptr, ssize_t len)
  *
  * return FAIL for failure, OK otherwise
  */
-int ml_replace(linenr_T lnum, char_u *line, bool copy)
+int ml_replace_buf(buf_T *buf, linenr_T lnum, char_u *line, bool copy)
 {
   if (line == NULL)             /* just checking... */
     return FAIL;
 
   /* When starting up, we might still need to create the memfile */
-  if (curbuf->b_ml.ml_mfp == NULL && open_buffer(FALSE, NULL, 0) == FAIL)
+  if (buf->b_ml.ml_mfp == NULL && open_buffer(FALSE, NULL, 0) == FAIL)
     return FAIL;
 
   bool readlen = true;
@@ -2430,22 +2441,22 @@ int ml_replace(linenr_T lnum, char_u *line, bool copy)
   if (copy) {
     line = vim_strsave(line);
   }
-  if (curbuf->b_ml.ml_line_lnum != lnum) {  // other line buffered
-    ml_flush_line(curbuf);  // flush it
-  } else if (curbuf->b_ml.ml_flags & ML_LINE_DIRTY) {  // same line allocated
-    ml_add_deleted_len(curbuf->b_ml.ml_line_ptr, -1);
+  if (buf->b_ml.ml_line_lnum != lnum) {  // other line buffered
+    ml_flush_line(buf);  // flush it
+  } else if (buf->b_ml.ml_flags & ML_LINE_DIRTY) {  // same line allocated
+    ml_add_deleted_len(buf->b_ml.ml_line_ptr, -1);
     readlen = false;  // already added the length
 
-    xfree(curbuf->b_ml.ml_line_ptr);  // free it
+    xfree(buf->b_ml.ml_line_ptr);  // free it
   }
 
-  if (readlen && kv_size(curbuf->update_callbacks)) {
-    ml_add_deleted_len(ml_get_buf(curbuf, lnum, false), -1);
+  if (readlen && kv_size(buf->update_callbacks)) {
+    ml_add_deleted_len(ml_get_buf(buf, lnum, false), -1);
   }
 
-  curbuf->b_ml.ml_line_ptr = line;
-  curbuf->b_ml.ml_line_lnum = lnum;
-  curbuf->b_ml.ml_flags = (curbuf->b_ml.ml_flags | ML_LINE_DIRTY) & ~ML_EMPTY;
+  buf->b_ml.ml_line_ptr = line;
+  buf->b_ml.ml_line_lnum = lnum;
+  buf->b_ml.ml_flags = (buf->b_ml.ml_flags | ML_LINE_DIRTY) & ~ML_EMPTY;
 
   return OK;
 }
@@ -3990,7 +4001,7 @@ long ml_find_line_or_offset(buf_T *buf, linenr_T lnum, long *offp, bool no_ff)
   int extra = 0;
 
   /* take care of cached line first */
-  ml_flush_line(curbuf);
+  ml_flush_line(buf);
 
   if (buf->b_ml.ml_usedchunks == -1
       || buf->b_ml.ml_chunksize == NULL