rm write_to_string

Author: SyMind

src/cached_source.rs

@@ -136,10 +136,6 @@ impl Source for CachedSource {
     }
   }
 
-  fn write_to_string(&self, string: &mut String) {
-    self.inner.write_to_string(string);
-  }
-
   fn to_writer(&self, writer: &mut dyn std::io::Write) -> std::io::Result<()> {
     self.inner.to_writer(writer)
   }

src/concat_source.rs

@@ -167,10 +167,10 @@ impl Source for ConcatSource {
     if children.len() == 1 {
       children[0].source()
     } else {
-      // Use to_writer to avoid multiple heap allocations that would occur
-      // when concatenating nested ConcatSource instances directly
       let mut string = String::with_capacity(self.size());
-      self.write_to_string(&mut string);
+      for chunk in self.rope() {
+        string.push_str(chunk);
+      }
       SourceValue::String(Cow::Owned(string))
     }
   }
@@ -215,12 +215,6 @@ impl Source for ConcatSource {
     result
   }
 
-  fn write_to_string(&self, string: &mut String) {
-    for child in self.optimized_children() {
-      child.write_to_string(string);
-    }
-  }
-
   fn to_writer(&self, writer: &mut dyn std::io::Write) -> std::io::Result<()> {
     for child in self.optimized_children() {
       child.to_writer(writer)?;

src/original_source.rs

@@ -77,10 +77,6 @@ impl Source for OriginalSource {
     get_map(object_pool, chunks.as_ref(), options)
   }
 
-  fn write_to_string(&self, string: &mut String) {
-    string.push_str(self.value.as_ref());
-  }
-
   fn to_writer(&self, writer: &mut dyn std::io::Write) -> std::io::Result<()> {
     writer.write_all(self.value.as_bytes())
   }

src/raw_source.rs

@@ -80,10 +80,6 @@ impl Source for RawStringSource {
     None
   }
 
-  fn write_to_string(&self, string: &mut String) {
-    string.push_str(self.0.as_ref());
-  }
-
   fn to_writer(&self, writer: &mut dyn std::io::Write) -> std::io::Result<()> {
     writer.write_all(self.0.as_bytes())
   }
@@ -230,10 +226,6 @@ impl Source for RawBufferSource {
     None
   }
 
-  fn write_to_string(&self, string: &mut String) {
-    string.push_str(self.get_or_init_value_as_string());
-  }
-
   fn to_writer(&self, writer: &mut dyn std::io::Write) -> std::io::Result<()> {
     writer.write_all(&self.value)
   }

src/replace_source.rs

@@ -238,106 +238,6 @@ impl Source for ReplaceSource {
     get_map(&ObjectPool::default(), chunks.as_ref(), options)
   }
 
-  #[allow(unsafe_code)]
-  fn write_to_string(&self, string: &mut String) {
-    let inner_chunks = self.inner.rope();
-
-    let mut pos: usize = 0;
-    let mut replacement_idx: usize = 0;
-    let mut replacement_end: Option<usize> = None;
-    let mut next_replacement: Option<usize> = (replacement_idx
-      < self.replacements.len())
-    .then(|| self.replacements[replacement_idx].start as usize);
-
-    'chunk_loop: for chunk in inner_chunks {
-      let mut chunk_pos = 0;
-      let end_pos = pos + chunk.len();
-
-      // Skip over when it has been replaced
-      if let Some(replacement_end) =
-        replacement_end.filter(|replacement_end| *replacement_end > pos)
-      {
-        // Skip over the whole chunk
-        if replacement_end >= end_pos {
-          pos = end_pos;
-          continue;
-        }
-        // Partially skip over chunk
-        chunk_pos = replacement_end - pos;
-        pos += chunk_pos;
-      }
-
-      // Is a replacement in the chunk?
-      while let Some(next_replacement_pos) = next_replacement
-        .filter(|next_replacement_pos| *next_replacement_pos < end_pos)
-      {
-        if next_replacement_pos > pos {
-          // Emit chunk until replacement
-          let offset = next_replacement_pos - pos;
-          let chunk_slice =
-            unsafe { &chunk.get_unchecked(chunk_pos..(chunk_pos + offset)) };
-          string.push_str(chunk_slice);
-          chunk_pos += offset;
-          pos = next_replacement_pos;
-        }
-        // Insert replacement content split into chunks by lines
-        let replacement =
-          unsafe { &self.replacements.get_unchecked(replacement_idx) };
-        string.push_str(&replacement.content);
-
-        // Remove replaced content by settings this variable
-        replacement_end = if let Some(replacement_end) = replacement_end {
-          Some(replacement_end.max(replacement.end as usize))
-        } else {
-          Some(replacement.end as usize)
-        };
-
-        // Move to next replacement
-        replacement_idx += 1;
-        next_replacement = if replacement_idx < self.replacements.len() {
-          Some(unsafe {
-            self.replacements.get_unchecked(replacement_idx).start as usize
-          })
-        } else {
-          None
-        };
-
-        // Skip over when it has been replaced
-        let offset = chunk.len() as i64 - end_pos as i64
-          + replacement_end.unwrap() as i64
-          - chunk_pos as i64;
-        if offset > 0 {
-          // Skip over whole chunk
-          if replacement_end
-            .is_some_and(|replacement_end| replacement_end >= end_pos)
-          {
-            pos = end_pos;
-            continue 'chunk_loop;
-          }
-
-          // Partially skip over chunk
-          chunk_pos += offset as usize;
-          pos += offset as usize;
-        }
-      }
-
-      // Emit remaining chunk
-      if chunk_pos < chunk.len() {
-        let chunk = unsafe { &chunk.get_unchecked(chunk_pos..) };
-        string.push_str(chunk);
-      }
-      pos = end_pos;
-    }
-
-    // Handle remaining replacements one by one
-    while replacement_idx < self.replacements.len() {
-      let content =
-        unsafe { &self.replacements.get_unchecked(replacement_idx).content };
-      string.push_str(content);
-      replacement_idx += 1;
-    }
-  }
-
   fn to_writer(&self, writer: &mut dyn std::io::Write) -> std::io::Result<()> {
     for text in self.rope() {
       writer.write_all(text.as_bytes())?;

src/source.rs

@@ -135,14 +135,6 @@ pub trait Source:
     self.dyn_hash(state);
   }
 
-  /// Appends the source content to the provided string buffer.
-  ///
-  /// This method efficiently writes the source content directly into an existing
-  /// string buffer, avoiding additional memory allocations when the buffer has
-  /// sufficient capacity. This is particularly useful for concatenating multiple
-  /// sources or building larger strings incrementally.
-  fn write_to_string(&self, string: &mut String);
-
   /// Writes the source into a writer, preferably a `std::io::BufWriter<std::io::Write>`.
   fn to_writer(&self, writer: &mut dyn std::io::Write) -> std::io::Result<()>;
 }
@@ -172,10 +164,6 @@ impl Source for BoxSource {
     self.as_ref().map(object_pool, options)
   }
 
-  fn write_to_string(&self, string: &mut String) {
-    self.as_ref().write_to_string(string)
-  }
-
   fn to_writer(&self, writer: &mut dyn std::io::Write) -> std::io::Result<()> {
     self.as_ref().to_writer(writer)
   }

src/source_map_source.rs

@@ -118,10 +118,6 @@ impl Source for SourceMapSource {
     get_map(object_pool, chunks.as_ref(), options)
   }
 
-  fn write_to_string(&self, string: &mut String) {
-    string.push_str(self.value.as_ref());
-  }
-
   fn to_writer(&self, writer: &mut dyn std::io::Write) -> std::io::Result<()> {
     writer.write_all(self.value.as_bytes())
   }

tests/compat_source.rs

@@ -39,10 +39,6 @@ impl Source for CompatSource {
     self.1.clone()
   }
 
-  fn write_to_string(&self, string: &mut String) {
-    string.push_str(self.0.as_ref())
-  }
-
   fn to_writer(&self, writer: &mut dyn std::io::Write) -> std::io::Result<()> {
     writer.write_all(self.0.as_bytes())
   }