diff --git a/src/ex_docmd.c b/src/ex_docmd.c
index 70f3e57..0bcb7fe 100644
--- a/src/ex_docmd.c
+++ b/src/ex_docmd.c
@@ -11099,7 +11099,7 @@
 static int ses_do_win(win_T *wp);
 static int ses_arglist(FILE *fd, char *cmd, garray_T *gap, int fullname, unsigned *flagp);
 static int ses_put_fname(FILE *fd, char_u *name, unsigned *flagp);
-static int ses_fname(FILE *fd, buf_T *buf, unsigned *flagp);
+static int ses_fname(FILE *fd, buf_T *buf, unsigned *flagp, int add_eol);
 
 /*
  * Write openfile commands for the current buffers to an .exrc file.
@@ -11195,7 +11195,7 @@
 	{
 	    if (fprintf(fd, "badd +%ld ", buf->b_wininfo == NULL ? 1L
 					   : buf->b_wininfo->wi_fpos.lnum) < 0
-		    || ses_fname(fd, buf, &ssop_flags) == FAIL)
+		    || ses_fname(fd, buf, &ssop_flags, TRUE) == FAIL)
 		return FAIL;
 	}
     }
@@ -11289,7 +11289,8 @@
 		    )
 	    {
 		if (fputs(need_tabnew ? "tabedit " : "edit ", fd) < 0
-			|| ses_fname(fd, wp->w_buffer, &ssop_flags) == FAIL)
+			      || ses_fname(fd, wp->w_buffer, &ssop_flags, TRUE)
+								       == FAIL)
 		    return FAIL;
 		need_tabnew = FALSE;
 		if (!wp->w_arg_idx_invalid)
@@ -11636,9 +11637,20 @@
 	    /*
 	     * Editing a file in this buffer: use ":edit file".
 	     * This may have side effects! (e.g., compressed or network file).
+	     *
+	     * Note, if a buffer for that file already exists, use :badd to
+	     * edit that buffer, to not lose folding information (:edit resets
+	     * folds in other buffers)
 	     */
-	    if (fputs("edit ", fd) < 0
-		    || ses_fname(fd, wp->w_buffer, flagp) == FAIL)
+	    if (fputs("if bufexists('", fd) < 0
+		    || ses_fname(fd, wp->w_buffer, flagp, FALSE) == FAIL
+		    || fputs("') | buffer ", fd) < 0
+		    || ses_fname(fd, wp->w_buffer, flagp, FALSE) == FAIL
+		    || fputs(" | else | edit ", fd) < 0
+		    || ses_fname(fd, wp->w_buffer, flagp, FALSE) == FAIL
+		    || fputs(" | endif", fd) < 0
+		    ||
+		put_eol(fd) == FAIL)
 		return FAIL;
 	}
 	else
@@ -11651,7 +11663,7 @@
 	    {
 		/* The buffer does have a name, but it's not a file name. */
 		if (fputs("file ", fd) < 0
-			|| ses_fname(fd, wp->w_buffer, flagp) == FAIL)
+			|| ses_fname(fd, wp->w_buffer, flagp, TRUE) == FAIL)
 		    return FAIL;
 	    }
 #endif
@@ -11823,11 +11835,11 @@
 
 /*
  * Write a buffer name to the session file.
- * Also ends the line.
+ * Also ends the line, if "add_eol" is TRUE.
  * Returns FAIL if writing fails.
  */
     static int
-ses_fname(FILE *fd, buf_T *buf, unsigned *flagp)
+ses_fname(FILE *fd, buf_T *buf, unsigned *flagp, int add_eol)
 {
     char_u	*name;
 
@@ -11846,7 +11858,8 @@
 	name = buf->b_sfname;
     else
 	name = buf->b_ffname;
-    if (ses_put_fname(fd, name, flagp) == FAIL || put_eol(fd) == FAIL)
+    if (ses_put_fname(fd, name, flagp) == FAIL
+	    || (add_eol && put_eol(fd) == FAIL))
 	return FAIL;
     return OK;
 }
