refactor: Cow is better

Author: SyMind

src/concat_source.rs

@@ -159,7 +159,7 @@ impl<'a> StreamChunks<'a> for ConcatSource {
     }
     let mut current_line_offset = 0;
     let mut current_column_offset = 0;
-    let mut source_mapping: HashMap<String, u32> = HashMap::default();
+    let mut source_mapping: HashMap<Cow<str>, u32> = HashMap::default();
     let mut name_mapping: HashMap<&str, u32> = HashMap::default();
     let mut need_to_close_mapping = false;
 
@@ -262,10 +262,10 @@ impl<'a> StreamChunks<'a> for ConcatSource {
           }
         },
         &mut |i, source, source_content| {
-          let mut global_index = source_mapping.get(source).copied();
+          let mut global_index = source_mapping.get(&source).copied();
           if global_index.is_none() {
             let len = source_mapping.len() as u32;
-            source_mapping.insert(source.to_owned(), len);
+            source_mapping.insert(source.clone(), len);
             on_source(len, source, source_content);
             global_index = Some(len);
           }

src/helpers.rs

@@ -35,7 +35,7 @@ pub fn get_map<'a, S: StreamChunks<'a>>(
       mappings.push(mapping);
     },
     // on_source
-    &mut |source_index, source: &str, source_content: Option<&str>| {
+    &mut |source_index, source, source_content| {
       let source_index = source_index as usize;
       if sources.len() <= source_index {
         sources.resize(source_index + 1, Cow::Borrowed(""));
@@ -49,7 +49,7 @@ pub fn get_map<'a, S: StreamChunks<'a>>(
       }
     },
     // on_name
-    &mut |name_index, name: &str| {
+    &mut |name_index, name| {
       let name_index = name_index as usize;
       if names.len() <= name_index {
         names.resize(name_index + 1, Cow::Borrowed(""));
@@ -75,10 +75,10 @@ pub trait StreamChunks<'a> {
 }
 
 /// [OnChunk] abstraction, see [webpack-sources onChunk](https://github.com/webpack/webpack-sources/blob/9f98066311d53a153fdc7c633422a1d086528027/lib/helpers/streamChunks.js#L13).
-pub type OnChunk<'a, 'b> = &'a mut dyn FnMut(Option<&'b str>, Mapping);
+pub type OnChunk<'a, 'b> = &'a mut dyn FnMut(Option<Cow<'b, str>>, Mapping);
 
 /// [OnSource] abstraction, see [webpack-sources onSource](https://github.com/webpack/webpack-sources/blob/9f98066311d53a153fdc7c633422a1d086528027/lib/helpers/streamChunks.js#L13).
-pub type OnSource<'a, 'b> = &'a mut dyn FnMut(u32, &str, Option<&'b str>);
+pub type OnSource<'a, 'b> = &'a mut dyn FnMut(u32, Cow<'b, str>, Option<&'b str>);
 
 /// [OnName] abstraction, see [webpack-sources onName](https://github.com/webpack/webpack-sources/blob/9f98066311d53a153fdc7c633422a1d086528027/lib/helpers/streamChunks.js#L13).
 pub type OnName<'a, 'b> = &'a mut dyn FnMut(u32, &'b str);
@@ -519,7 +519,7 @@ pub fn stream_chunks_of_raw_source<'a>(
   let mut last_line = None;
   for l in split_into_lines(source) {
     on_chunk(
-      Some(l),
+      Some(Cow::Borrowed(l)),
       Mapping {
         generated_line: line,
         generated_column: 0,
@@ -580,13 +580,13 @@ pub fn stream_chunks_of_source_map<'a>(
   }
 }
 
-fn get_source(source_map: &SourceMap, source: &str) -> String {
+fn get_source<'a>(source_map: &SourceMap, source: &'a str) -> Cow<'a, str> {
   let source_root = source_map.source_root();
   match source_root {
-    Some(root) if root.is_empty() => source.to_string(),
-    Some(root) if root.ends_with('/') => format!("{}{}", root, source),
-    Some(root) => format!("{}/{}", root, source),
-    None => source.to_string(),
+    Some(root) if root.is_empty() => Cow::Borrowed(source),
+    Some(root) if root.ends_with('/') => Cow::Owned(format!("{}{}", root, source)),
+    Some(root) => Cow::Owned(format!("{}/{}", root, source)),
+    None => Cow::Borrowed(source),
   }
 }
 
@@ -604,7 +604,7 @@ fn stream_chunks_of_source_map_final<'a>(
   for (i, source) in source_map.sources().iter().enumerate() {
     on_source(
       i as u32,
-      &get_source(source_map, source),
+      get_source(source_map, source),
       source_map.get_source_content(i),
     )
   }
@@ -656,7 +656,7 @@ fn stream_chunks_of_source_map_full<'a>(
   for (i, source) in source_map.sources().iter().enumerate() {
     on_source(
       i as u32,
-      &get_source(source_map, source),
+      get_source(source_map, source),
       source_map.get_source_content(i),
     )
   }
@@ -684,7 +684,7 @@ fn stream_chunks_of_source_map_full<'a>(
         let chunk = &source[tracking_generated_index..current_generated_index];
         if !chunk.is_empty() {
           on_chunk(
-            Some(chunk),
+            Some(Cow::Borrowed(chunk)),
             Mapping {
               generated_line: tracking_generated_line,
               generated_column: tracking_generated_column,
@@ -710,7 +710,7 @@ fn stream_chunks_of_source_map_full<'a>(
         let chunk =
           &source[tracking_generated_index..current_generated_index + 1];
         on_chunk(
-          Some(chunk),
+          Some(Cow::Borrowed(chunk)),
           Mapping {
             generated_line: tracking_generated_line,
             generated_column: tracking_generated_column,
@@ -732,7 +732,7 @@ fn stream_chunks_of_source_map_full<'a>(
   if tracking_generated_index < source.len() {
     let chunk = &source[tracking_generated_index..];
     on_chunk(
-      Some(chunk),
+      Some(Cow::Borrowed(chunk)),
       Mapping {
         generated_line: tracking_generated_line,
         generated_column: tracking_generated_column,
@@ -764,7 +764,7 @@ fn stream_chunks_of_source_map_lines_final<'a>(
   for (i, source) in source_map.sources().iter().enumerate() {
     on_source(
       i as u32,
-      &get_source(source_map, source),
+      get_source(source_map, source),
       source_map.get_source_content(i),
     )
   }
@@ -819,7 +819,7 @@ fn stream_chunks_of_source_map_lines_full<'a>(
   for (i, source) in source_map.sources().iter().enumerate() {
     on_source(
       i as u32,
-      &get_source(source_map, source),
+      get_source(source_map, source),
       source_map.get_source_content(i),
     )
   }
@@ -833,8 +833,9 @@ fn stream_chunks_of_source_map_lines_full<'a>(
     }
     while mapping.generated_line > current_generated_line {
       if current_generated_line as usize <= lines.len() {
+        let chunk = lines[current_generated_line as usize - 1];
         on_chunk(
-          Some(lines[current_generated_line as usize - 1]),
+          Some(Cow::Borrowed(chunk)),
           Mapping {
             generated_line: current_generated_line,
             generated_column: 0,
@@ -848,8 +849,9 @@ fn stream_chunks_of_source_map_lines_full<'a>(
       .original
       .filter(|_| mapping.generated_line as usize <= lines.len())
     {
+      let chunk = lines[current_generated_line as usize - 1];
       on_chunk(
-        Some(lines[mapping.generated_line as usize - 1]),
+        Some(Cow::Borrowed(chunk)),
         Mapping {
           generated_line: mapping.generated_line,
           generated_column: 0,
@@ -868,8 +870,9 @@ fn stream_chunks_of_source_map_lines_full<'a>(
     on_mapping(mapping);
   }
   while current_generated_line as usize <= lines.len() {
+    let chunk = lines[current_generated_line as usize - 1];
     on_chunk(
-      Some(lines[current_generated_line as usize - 1]),
+      Some(Cow::Borrowed(chunk)),
       Mapping {
         generated_line: current_generated_line,
         generated_column: 0,
@@ -900,24 +903,26 @@ struct SourceMapLineData<'a> {
 
 #[derive(Debug)]
 struct SourceMapLineChunk<'a> {
-  content: &'a str,
-  cached: OnceCell<WithIndices<&'a str>>,
+  content: Cow<'a, str>,
+  cached: OnceCell<WithIndices<Cow<'a, str>>>,
 }
 
 impl<'a> SourceMapLineChunk<'a> {
-  pub fn new(content: &'a str) -> Self {
+  pub fn new(content: Cow<'a, str>) -> Self {
     Self {
       content,
       cached: OnceCell::new(),
     }
   }
 
   pub fn substring(&self, start_index: usize, end_index: usize) -> &str {
-    let cached = self.cached.get_or_init(|| WithIndices::new(self.content));
+    let cached = self.cached.get_or_init(|| WithIndices::new(self.content.clone()));
     cached.substring(start_index, end_index)
   }
 }
 
+type InnerSourceIndexValueMapping<'a> = HashMap<i64, (Cow<'a, str>, Option<&'a str>)>;
+
 #[allow(clippy::too_many_arguments)]
 pub fn stream_chunks_of_combined_source_map<'a>(
   source: &'a str,
@@ -933,7 +938,7 @@ pub fn stream_chunks_of_combined_source_map<'a>(
 ) -> GeneratedInfo {
   let on_source = RefCell::new(on_source);
   let inner_source: RefCell<Option<&str>> = RefCell::new(inner_source);
-  let source_mapping: RefCell<HashMap<String, u32>> =
+  let source_mapping: RefCell<HashMap<Cow<str>, u32>> =
     RefCell::new(HashMap::default());
   let mut name_mapping: HashMap<&str, u32> = HashMap::default();
   let source_index_mapping: RefCell<HashMap<i64, i64>> =
@@ -945,9 +950,7 @@ pub fn stream_chunks_of_combined_source_map<'a>(
   let inner_source_index: RefCell<i64> = RefCell::new(-2);
   let inner_source_index_mapping: RefCell<HashMap<i64, i64>> =
     RefCell::new(HashMap::default());
-  let inner_source_index_value_mapping: RefCell<
-    HashMap<i64, (String, Option<&str>)>,
-  > = RefCell::new(HashMap::default());
+  let inner_source_index_value_mapping: RefCell<InnerSourceIndexValueMapping> = RefCell::new(HashMap::default());
   let inner_source_contents: RefCell<HashMap<i64, Option<&str>>> =
     RefCell::new(HashMap::default());
   let inner_source_content_lines: InnerSourceContentLine =
@@ -1080,11 +1083,11 @@ pub fn stream_chunks_of_combined_source_map<'a>(
                 .unwrap_or(("".into(), None));
               let mut source_mapping = source_mapping.borrow_mut();
               let mut global_index =
-                source_mapping.get(&source.to_string()).copied();
+                source_mapping.get(&source).copied();
               if global_index.is_none() {
                 let len = source_mapping.len() as u32;
-                source_mapping.insert(source.to_string(), len);
-                on_source.borrow_mut()(len, &source, source_content);
+                source_mapping.insert(source.clone(), len);
+                on_source.borrow_mut()(len, source, source_content);
                 global_index = Some(len);
               }
               source_index = global_index.unwrap() as i64;
@@ -1225,7 +1228,7 @@ pub fn stream_chunks_of_combined_source_map<'a>(
               source_mapping.insert(source.into(), len);
               on_source.borrow_mut()(
                 len,
-                inner_source_name,
+                Cow::Borrowed(inner_source_name),
                 *inner_source.borrow(),
               );
               global_index = Some(len);
@@ -1360,7 +1363,7 @@ pub fn stream_chunks_of_combined_source_map<'a>(
             inner_source_index_mapping.borrow_mut().insert(i, -2);
             inner_source_index_value_mapping
               .borrow_mut()
-              .insert(i, (source.to_string(), source_content));
+              .insert(i, (source, source_content));
           },
           &mut |i, name| {
             let i = i as i64;
@@ -1374,10 +1377,10 @@ pub fn stream_chunks_of_combined_source_map<'a>(
         );
       } else {
         let mut source_mapping = source_mapping.borrow_mut();
-        let mut global_index = source_mapping.get(source).copied();
+        let mut global_index = source_mapping.get(&source).copied();
         if global_index.is_none() {
           let len = source_mapping.len() as u32;
-          source_mapping.insert(source.to_string(), len);
+          source_mapping.insert(source.clone(), len);
           on_source.borrow_mut()(len, source, source_content);
           global_index = Some(len);
         }

src/original_source.rs

@@ -106,7 +106,7 @@ impl<'a> StreamChunks<'a> for OriginalSource {
     on_source: OnSource<'_, 'a>,
     _on_name: OnName,
   ) -> crate::helpers::GeneratedInfo {
-    on_source(0, &self.name, Some(&self.value));
+    on_source(0, Cow::Borrowed(&self.name), Some(&self.value));
     if options.columns {
       // With column info we need to read all lines and split them
       let mut line = 1;
@@ -116,7 +116,7 @@ impl<'a> StreamChunks<'a> for OriginalSource {
         if is_end_of_line && token.len() == 1 {
           if !options.final_source {
             on_chunk(
-              Some(token),
+              Some(Cow::Borrowed(token)),
               Mapping {
                 generated_line: line,
                 generated_column: column,
@@ -126,7 +126,7 @@ impl<'a> StreamChunks<'a> for OriginalSource {
           }
         } else {
           on_chunk(
-            (!options.final_source).then_some(token),
+            (!options.final_source).then_some(Cow::Borrowed(token)),
             Mapping {
               generated_line: line,
               generated_column: column,
@@ -195,7 +195,7 @@ impl<'a> StreamChunks<'a> for OriginalSource {
       let mut last_line = None;
       for l in split_into_lines(&self.value) {
         on_chunk(
-          (!options.final_source).then_some(l),
+          (!options.final_source).then_some(Cow::Borrowed(l)),
           Mapping {
             generated_line: line,
             generated_column: 0,

src/replace_source.rs

@@ -41,7 +41,6 @@ pub struct ReplaceSource<T> {
   replacements: Mutex<Vec<Replacement>>,
   /// Whether `replacements` is sorted.
   is_sorted: AtomicBool,
-  remainder: OnceLock<String>,
 }
 
 /// Enforce replacement order when two replacement start and end are both equal
@@ -91,7 +90,6 @@ impl<T> ReplaceSource<T> {
       inner_source_code: OnceLock::new(),
       replacements: Mutex::new(Vec::new()),
       is_sorted: AtomicBool::new(true),
-      remainder: OnceLock::new(),
     }
   }
 
@@ -385,7 +383,7 @@ impl<'a, T: Source> StreamChunks<'a> for ReplaceSource<T> {
             let chunk_slice =
               &chunk[chunk_pos as usize..(chunk_pos + offset) as usize];
             on_chunk(
-              Some(chunk_slice),
+              Some(Cow::Owned(chunk_slice.to_string())),
               Mapping {
                 generated_line: line as u32,
                 generated_column: ((mapping.generated_column as i64)
@@ -457,7 +455,7 @@ impl<'a, T: Source> StreamChunks<'a> for ReplaceSource<T> {
           }
           for (m, content_line) in lines.iter().enumerate() {
             on_chunk(
-              Some(content_line),
+              Some(Cow::Borrowed(content_line)),
               Mapping {
                 generated_line: line as u32,
                 generated_column: ((mapping.generated_column as i64)
@@ -568,7 +566,7 @@ impl<'a, T: Source> StreamChunks<'a> for ReplaceSource<T> {
           let chunk_slice = if chunk_pos == 0 {
             chunk
           } else {
-            &chunk[chunk_pos as usize..]
+            Cow::Owned(chunk[chunk_pos as usize..].to_string())
           };
           let line = mapping.generated_line as i64 + generated_line_offset;
           on_chunk(
@@ -624,21 +622,18 @@ impl<'a, T: Source> StreamChunks<'a> for ReplaceSource<T> {
     );
 
     // Handle remaining replacements
-    let remainder = self.remainder.get_or_init(|| {
-      let mut remainder = String::new();
-      while i < repls.len() {
-        remainder += &repls[i].content;
-        i += 1;
-      }
-      remainder
-    });
+    let mut remainder = String::new();
+    while i < repls.len() {
+      remainder += &repls[i].content;
+      i += 1;
+    }
 
     // Insert remaining replacements content split into chunks by lines
     let mut line = result.generated_line as i64 + generated_line_offset;
-    let matches: Vec<&str> = split_into_lines(remainder).collect();
+    let matches: Vec<&str> = split_into_lines(&remainder).collect();
     for (m, content_line) in matches.iter().enumerate() {
       on_chunk(
-        Some(content_line),
+        Some(Cow::Owned(content_line.to_string())),
         Mapping {
           generated_line: line as u32,
           generated_column: ((result.generated_column as i64)
@@ -684,8 +679,7 @@ impl<T: Source> Clone for ReplaceSource<T> {
       inner: self.inner.clone(),
       inner_source_code: self.inner_source_code.clone(),
       replacements: Mutex::new(self.replacements().clone()),
-      is_sorted: AtomicBool::new(self.is_sorted.load(Ordering::SeqCst)),
-      remainder: OnceLock::new(),
+      is_sorted: AtomicBool::new(self.is_sorted.load(Ordering::SeqCst))
     }
   }
 }