refactor(vim): avoid overlapping edits on change surrounds

Update `Vim.change_surround` in order to ensure that there's no
overlapping edits by keeping track of where the open string range ends
and ensuring that the closing string range start does not go lower than
the open string range end.

Author: dinocosta

crates/vim/src/surrounds.rs

@@ -282,20 +282,20 @@ impl Vim {
                             // that the end replacement string does not exceed
                             // this value. Helpful when dealing with newlines.
                             let mut edit_len = 0;
-                            let mut forward_end: Option<usize> = None;
                             let mut chars_and_offset = display_map
                                 .buffer_chars_at(range.start.to_offset(&display_map, Bias::Left))
                                 .peekable();
 
+                            let mut open_end = 0;
                             while let Some((ch, offset)) = chars_and_offset.next() {
                                 if ch.to_string() == will_replace_pair.start {
                                     let mut open_str = pair.start.clone();
                                     let start = offset;
-                                    let mut end = start + 1;
+                                    open_end = start + 1;
                                     while let Some((next_ch, _)) = chars_and_offset.next()
-                                        && next_ch.to_string() == " "
+                                        && next_ch == ' '
                                     {
-                                        end += 1;
+                                        open_end += 1;
 
                                         if preserve_space {
                                             open_str.push(next_ch);
@@ -306,10 +306,9 @@ impl Vim {
                                         open_str.push(' ');
                                     };
 
-                                    edit_len = end - start;
-                                    edits.push((start..end, open_str));
+                                    edit_len = open_end - start;
+                                    edits.push((start..open_end, open_str));
                                     anchors.push(start..start);
-                                    forward_end = Some(end);
                                     break;
                                 }
                             }
@@ -321,27 +320,25 @@ impl Vim {
                                 .peekable();
                             while let Some((ch, offset)) = reverse_chars_and_offsets.next() {
                                 if ch.to_string() == will_replace_pair.end {
-                                    let mut close_str = String::new();
+                                    let mut close_str = pair.end.clone();
                                     let mut start = offset;
                                     let end = start + 1;
                                     while let Some((next_ch, _)) = reverse_chars_and_offsets.next()
-                                        && (next_ch.to_string() == " "
-                                            && forward_end
-                                                .map_or(true, |open_end| start > open_end))
-                                        && close_str.len() < edit_len - 1
+                                        && next_ch == ' '
+                                        && close_str.len() < edit_len
+                                        && start > open_end
                                     {
                                         start -= 1;
 
                                         if preserve_space {
-                                            close_str.push(next_ch);
+                                            close_str.insert(0, next_ch);
                                         }
                                     }
 
                                     if add_space {
-                                        close_str.push(' ');
+                                        close_str.insert(0, ' ');
                                     };
 
-                                    close_str.push_str(&pair.end);
                                     edits.push((start..end, close_str));
                                     break;
                                 }