patch 8.0.0457: using :move messes up manual folds

Problem:    Using :move messes up manual folds.
Solution:   Split adjusting marks and folds.  Add foldMoveRange(). (neovim
            patch #6221)

Author: brammool

src/ex_cmds.c

@@ -800,6 +800,8 @@ do_move(linenr_T line1, linenr_T line2, linenr_T dest)
     linenr_T	last_line;  /* Last line in file after adding new text */
 #ifdef FEAT_FOLDING
     int		isFolded;
+    win_T	*win;
+    tabpage_T	*tp;
 
     /* Moving lines seems to corrupt the folds, delete folding info now
      * and recreate it when finished.  Don't do this for manual folding, it
@@ -851,24 +853,34 @@ do_move(linenr_T line1, linenr_T line2, linenr_T dest)
      * their final destination at the new text position -- webb
      */
     last_line = curbuf->b_ml.ml_line_count;
-    mark_adjust(line1, line2, last_line - line2, 0L);
-    changed_lines(last_line - num_lines + 1, 0, last_line + 1, num_lines);
+    mark_adjust_nofold(line1, line2, last_line - line2, 0L);
     if (dest >= line2)
     {
-	mark_adjust(line2 + 1, dest, -num_lines, 0L);
+	mark_adjust_nofold(line2 + 1, dest, -num_lines, 0L);
+#ifdef FEAT_FOLDING
+	FOR_ALL_TAB_WINDOWS(tp, win) {
+	    if (win->w_buffer == curbuf)
+		foldMoveRange(&win->w_folds, line1, line2, dest);
+	}
+#endif
 	curbuf->b_op_start.lnum = dest - num_lines + 1;
 	curbuf->b_op_end.lnum = dest;
     }
     else
     {
-	mark_adjust(dest + 1, line1 - 1, num_lines, 0L);
+	mark_adjust_nofold(dest + 1, line1 - 1, num_lines, 0L);
+#ifdef FEAT_FOLDING
+	FOR_ALL_TAB_WINDOWS(tp, win) {
+	    if (win->w_buffer == curbuf)
+		foldMoveRange(&win->w_folds, dest + 1, line1 - 1, line2);
+	}
+#endif
 	curbuf->b_op_start.lnum = dest + 1;
 	curbuf->b_op_end.lnum = dest + num_lines;
     }
     curbuf->b_op_start.col = curbuf->b_op_end.col = 0;
-    mark_adjust(last_line - num_lines + 1, last_line,
+    mark_adjust_nofold(last_line - num_lines + 1, last_line,
 					     -(last_line - dest - extra), 0L);
-    changed_lines(last_line - num_lines + 1, 0, last_line + 1, -extra);
 
     /*
      * Now we delete the original text -- webb
@@ -907,9 +919,9 @@ do_move(linenr_T line1, linenr_T line2, linenr_T dest)
 	changed_lines(dest + 1, 0, line1 + num_lines, 0L);
 
 #ifdef FEAT_FOLDING
-	/* recreate folds */
-	if (isFolded)
-	    foldUpdateAll(curwin);
+    /* recreate folds */
+    if (isFolded)
+	foldUpdateAll(curwin);
 #endif
 
     return OK;

src/fold.c

@@ -64,6 +64,7 @@ static void deleteFoldMarkers(fold_T *fp, int recursive, linenr_T lnum_off);
 static void foldDelMarker(linenr_T lnum, char_u *marker, int markerlen);
 static void foldUpdateIEMS(win_T *wp, linenr_T top, linenr_T bot);
 static void parseMarker(win_T *wp);
+static void foldMoveRange_int(garray_T *gap, linenr_T line1, linenr_T line2, linenr_T dest);
 
 static char *e_nofold = N_("E490: No fold found");
 
@@ -1075,6 +1076,12 @@ foldAdjustCursor(void)
     (void)hasFolding(curwin->w_cursor.lnum, &curwin->w_cursor.lnum, NULL);
 }
 
+/* foldMoveRange() {{{2 */
+    void
+foldMoveRange(garray_T *gap, linenr_T line1, linenr_T line2, linenr_T dest)
+{
+    foldMoveRange_int(gap, line1, line2, dest);
+}
 /* Internal functions for "fold_T" {{{1 */
 /* cloneFoldGrowArray() {{{2 */
 /*
@@ -2968,6 +2975,182 @@ foldRemove(garray_T *gap, linenr_T top, linenr_T bot)
     }
 }
 
+/* foldReverseOrder() {{{2 */
+    static void
+foldReverseOrder(garray_T *gap, linenr_T start, linenr_T end)
+{
+    fold_T *left, *right;
+    fold_T tmp;
+
+    for (; start < end; start++, end--)
+    {
+	left = (fold_T *)gap->ga_data + start;
+	right = (fold_T *)gap->ga_data + end;
+	tmp  = *left;
+	*left = *right;
+	*right = tmp;
+    }
+}
+
+/* foldMoveRange_int() {{{2 */
+/*
+ * Move folds within the inclusive range "line1" to "line2" to after "dest"
+ * requires "line1" <= "line2" <= "dest"
+ *
+ * There are the following situations for the first fold at or below line1 - 1.
+ *       1  2  3  4
+ *       1  2  3  4
+ * line1    2  3  4
+ *          2  3  4  5  6  7
+ * line2       3  4  5  6  7
+ *             3  4     6  7  8  9
+ * dest           4        7  8  9
+ *                4        7  8    10
+ *                4        7  8    10
+ *
+ * In the following descriptions, "moved" means moving in the buffer, *and* in
+ * the fold array.
+ * Meanwhile, "shifted" just means moving in the buffer.
+ * 1. not changed
+ * 2. truncated above line1
+ * 3. length reduced by  line2 - line1, folds starting between the end of 3 and
+ *    dest are truncated and shifted up
+ * 4. internal folds moved (from [line1, line2] to dest)
+ * 5. moved to dest.
+ * 6. truncated below line2 and moved.
+ * 7. length reduced by line2 - dest, folds starting between line2 and dest are
+ *    removed, top is moved down by move_len.
+ * 8. truncated below dest and shifted up.
+ * 9. shifted up
+ * 10. not changed
+ */
+
+    static void
+truncate_fold(fold_T *fp, linenr_T end)
+{
+    foldRemove(&fp->fd_nested, end - fp->fd_top, MAXLNUM);
+    fp->fd_len = end - fp->fd_top + 1;
+}
+
+#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)))
+
+    static void
+foldMoveRange_int(garray_T *gap, linenr_T line1, linenr_T line2, linenr_T dest)
+{
+    fold_T *fp;
+    linenr_T range_len = line2 - line1 + 1;
+    linenr_T move_len = dest - line2;
+    int at_start = foldFind(gap, line1 - 1, &fp);
+    size_t move_start = 0, move_end = 0, dest_index = 0;
+
+    if (at_start)
+    {
+	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 -
+		    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, line2 -
+		    fp->fd_top, MAXLNUM, -range_len);
+	    fp->fd_len -= range_len;
+	}
+	else
+	    /* Case 2 truncate fold, folds after this one must be dealt with. */
+	    truncate_fold(fp, line1);
+
+	/* Look at the next fold, and treat that one as if it were the first
+	 * after  "line1" (because now it is). */
+	fp = fp + 1;
+    }
+
+    if (!valid_fold(fp, gap) || fp->fd_top > dest)
+    {
+	/* Case 10
+	 * No folds after "line1" and before "dest"
+	 */
+	return;
+    }
+    else if (fp->fd_top > line2)
+    {
+	for (; valid_fold(fp, gap) && fold_end(fp) < dest; fp++)
+	/* Case 9. (for all case 9's) -- shift up. */
+	    fp->fd_top -= range_len;
+
+	if (valid_fold(fp, gap) && fp->fd_top < dest)
+	{
+	    /* Case 8. -- ensure truncated at dest, shift up */
+	    truncate_fold(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, dest -
+		fp->fd_top, MAXLNUM, -move_len);
+	fp->fd_len -= move_len;
+	fp->fd_top += move_len;
+	return;
+    }
+
+    /* Case 5 or 6
+     * changes rely on whether there are folds between the end of 
+     * this fold and "dest".
+     */
+    move_start = fold_index(fp, gap);
+
+    for (; valid_fold(fp, gap) && fp->fd_top <= dest; fp++)
+    {
+	if (fp->fd_top <= line2)
+	{
+	    /* 1. 2. or 3. */
+	    if (fold_end(fp) > line2)
+		/* 2. or 3., truncate before moving */
+		truncate_fold(fp, line2);
+
+	    fp->fd_top += move_len;
+	    continue;
+	}
+
+	/* Record index of the first fold after the moved range. */
+	if (move_end == 0)
+	    move_end = fold_index(fp, gap);
+
+	if (fold_end(fp) > dest)
+	    truncate_fold(fp, dest);
+
+	fp->fd_top -= range_len;
+    }
+
+    dest_index = fold_index(fp, gap);
+
+    /*
+     * All folds are now correct, but they are not necessarily in the correct
+     * order. We have to swap folds in the range [move_end, dest_index) with
+     * those in the range [move_start, move_end).
+     */
+    foldReverseOrder(gap, move_start, dest_index - 1);
+    foldReverseOrder(gap, move_start, move_start + dest_index - move_end - 1);
+    foldReverseOrder(gap, move_start + dest_index - move_end, dest_index - 1);
+}
+#undef fold_end
+#undef valid_fold
+#undef fold_index
+
 /* foldMerge() {{{2 */
 /*
  * Merge two adjacent folds (and the nested ones in them).

src/mark.c

@@ -37,6 +37,8 @@ static void cleanup_jumplist(void);
 #ifdef FEAT_VIMINFO
 static void write_one_filemark(FILE *fp, xfmark_T *fm, int c1, int c2);
 #endif
+static void mark_adjust_internal(linenr_T line1, linenr_T line2, long amount,
+    long amount_after, int adjust_folds);
 
 /*
  * Set named mark "c" at current cursor position.
@@ -1028,6 +1030,27 @@ mark_adjust(
     linenr_T	line2,
     long	amount,
     long	amount_after)
+{
+    mark_adjust_internal(line1, line2, amount, amount_after, TRUE);
+}
+
+    void
+mark_adjust_nofold(
+    linenr_T line1,
+    linenr_T line2,
+    long amount,
+    long amount_after)
+{
+    mark_adjust_internal(line1, line2, amount, amount_after, FALSE);
+}
+
+    static void
+mark_adjust_internal(
+    linenr_T line1,
+    linenr_T line2,
+    long amount,
+    long amount_after,
+    int adjust_folds UNUSED)
 {
     int		i;
     int		fnum = curbuf->b_fnum;
@@ -1174,7 +1197,8 @@ mark_adjust(
 
 #ifdef FEAT_FOLDING
 	    /* adjust folds */
-	    foldMarkAdjust(win, line1, line2, amount, amount_after);
+	    if (adjust_folds)
+		foldMarkAdjust(win, line1, line2, amount, amount_after);
 #endif
 	}
     }

src/proto/fold.pro

@@ -31,6 +31,7 @@ void foldInitWin(win_T *new_win);
 int find_wl_entry(win_T *win, linenr_T lnum);
 void foldAdjustVisual(void);
 void foldAdjustCursor(void);
+void foldMoveRange(garray_T *gap, linenr_T line1, linenr_T line2, linenr_T dest);
 void cloneFoldGrowArray(garray_T *from, garray_T *to);
 void deleteFoldRecurse(garray_T *gap);
 void foldMarkAdjust(win_T *wp, linenr_T line1, linenr_T line2, long amount, long amount_after);

src/proto/mark.pro

@@ -19,6 +19,7 @@ void ex_jumps(exarg_T *eap);
 void ex_clearjumps(exarg_T *eap);
 void ex_changes(exarg_T *eap);
 void mark_adjust(linenr_T line1, linenr_T line2, long amount, long amount_after);
+void mark_adjust_nofold(linenr_T line1, linenr_T line2, long amount, long amount_after);
 void mark_col_adjust(linenr_T lnum, colnr_T mincol, long lnum_amount, long col_amount);
 void copy_jumplist(win_T *from, win_T *to);
 void free_jumplist(win_T *wp);