Refactor remove using update_with_inner

Author: hyf0

src/chunk.rs

@@ -2,6 +2,22 @@ use std::collections::VecDeque;
 
 use crate::{span::Span, ChunkIdx, CowStr, TextSize};
 
+#[derive(Debug)]
+pub struct EditOptions {
+    /// `true` will clear the `intro` and `outro` of the [Chunk]
+    pub overwrite: bool,
+    pub store_name: bool,
+}
+
+impl Default for EditOptions {
+    fn default() -> Self {
+        Self {
+            overwrite: true,
+            store_name: false,
+        }
+    }
+}
+
 #[derive(Debug, Default)]
 pub struct Chunk<'str> {
     pub intro: VecDeque<CowStr<'str>>,
@@ -58,7 +74,7 @@ impl<'str> Chunk<'str> {
         let last_slice_span = Span(text_index, self.end());
         let mut new_chunk = Chunk::new(last_slice_span);
         if self.is_edited() {
-            new_chunk.edit("".into(), true, false);
+            new_chunk.edit("".into(), Default::default());
         }
         std::mem::swap(&mut new_chunk.outro, &mut self.outro);
         self.span = first_slice_span;
@@ -79,12 +95,12 @@ impl<'str> Chunk<'str> {
         intro_iter.chain(Some(source_frag)).chain(outro_iter)
     }
 
-    pub fn edit(&mut self, content: CowStr<'str>, overwrite: bool, store_name: bool) {
-        if overwrite {
+    pub fn edit(&mut self, content: CowStr<'str>, opts: EditOptions) {
+        if opts.overwrite {
             self.intro.clear();
             self.outro.clear();
         }
-        self.store_name = store_name;
+        self.store_name = opts.store_name;
         self.edited_content = Some(content);
     }
 

src/magic_string/mod.rs

@@ -156,33 +156,7 @@ impl<'s> MagicString<'s> {
         ret
     }
 
-    pub fn remove(&mut self, start: TextSize, end: TextSize) -> &mut Self {
-        if start == end {
-            return self;
-        }
-
-        assert!(end <= self.source.len(), "end is out of bounds");
-        assert!(start < end, "end must be greater than start");
-
-        self.split_at(start);
-        self.split_at(end);
-
-        let mut searched = self.chunk_by_start.get(&start).copied();
-
-        while let Some(chunk_idx) = searched {
-            let chunk = &mut self.chunks[chunk_idx];
-            chunk.intro.clear();
-            chunk.outro.clear();
-            chunk.edit("".into(), true, false);
-            searched = if end == chunk.end() {
-                None
-            } else {
-                self.chunk_by_start.get(&chunk.end()).copied()
-            }
-        }
-
-        self
-    }
+   
 
     // --- private
 

src/magic_string/mutation.rs

@@ -1,4 +1,4 @@
-use crate::{CowStr, MagicString, TextSize};
+use crate::{chunk::EditOptions, CowStr, MagicString, TextSize};
 
 #[derive(Debug, Default, Clone)]
 pub struct UpdateOptions {
@@ -7,8 +7,21 @@ pub struct UpdateOptions {
 }
 
 impl<'text> MagicString<'text> {
-    pub fn update(&mut self, start: TextSize, end: TextSize, content: impl Into<CowStr<'text>>) -> &mut Self {
-        self.update_with(start, end, content, Default::default())
+    pub fn update(
+        &mut self,
+        start: TextSize,
+        end: TextSize,
+        content: impl Into<CowStr<'text>>,
+    ) -> &mut Self {
+        self.update_with(
+            start,
+            end,
+            content,
+            UpdateOptions {
+                store_name: false,
+                overwrite: true,
+            },
+        )
     }
 
     pub fn update_with(
@@ -18,17 +31,67 @@ impl<'text> MagicString<'text> {
         content: impl Into<CowStr<'text>>,
         opts: UpdateOptions,
     ) -> &mut Self {
+        self.update_with_inner(start, end, content.into(), opts, true);
+        self
+    }
+
+    pub fn remove(&mut self, start: TextSize, end: TextSize) -> &mut Self {
+        self.update_with_inner(
+            start,
+            end,
+            "".into(),
+            UpdateOptions {
+                store_name: false,
+                overwrite: true,
+            },
+            false,
+        );
+
+        self
+    }
+
+    // --- private
+
+    fn update_with_inner(
+        &mut self,
+        start: TextSize,
+        end: TextSize,
+        content: CowStr<'text>,
+        opts: UpdateOptions,
+        panic_if_start_equal_end: bool,
+    ) -> &mut Self {
+        if panic_if_start_equal_end && start == end {
+            panic!(
+                "Cannot overwrite a zero-length range – use append_left or prepend_right instead"
+            )
+        }
         assert!(start < end);
         self.split_at(start);
         self.split_at(end);
 
-        let first = self.chunk_by_start.get(&start).unwrap();
-        let end = self.chunk_by_end.get(&start).unwrap();
+        let start_idx = self.chunk_by_start.get(&start).copied().unwrap();
+        let end_idx = self.chunk_by_end.get(&end).copied().unwrap();
 
-        // let chunk_after_next =
+        let start_chunk = &mut self.chunks[start_idx];
+        start_chunk.edit(
+            content.into(),
+            EditOptions {
+                overwrite: opts.overwrite,
+                store_name: opts.store_name,
+            },
+        );
 
-        self.chunks[*first].edit(content.into(), opts.overwrite, opts.store_name);
+        let mut rest_chunk_idx = if start_idx != end_idx {
+            start_chunk.next.unwrap()
+        } else {
+            return self;
+        };
 
+        while rest_chunk_idx != end_idx {
+            let rest_chunk = &mut self.chunks[rest_chunk_idx];
+            rest_chunk.edit("".into(), Default::default());
+            rest_chunk_idx = rest_chunk.next.unwrap();
+        }
         self
     }
 }

src/source_map.rs

@@ -10,7 +10,6 @@ pub struct SourceMap {
 }
 
 impl SourceMap {
-    /// ## Generate SourceMap in JSON format
     pub fn to_string(&self) -> String {
         serde_json::to_string(self).unwrap()
     }