perf: add rope

Author: SyMind

src/cached_source.rs

@@ -21,6 +21,7 @@ use crate::{
 struct CachedData {
   hash: OnceLock<u64>,
   size: OnceLock<usize>,
+  source: OnceLock<Vec<&'static str>>,
   columns_map: OnceLock<Option<SourceMap>>,
   line_only_map: OnceLock<Option<SourceMap>>,
 }
@@ -83,7 +84,20 @@ impl CachedSource {
 
 impl Source for CachedSource {
   fn source(&self) -> SourceValue {
-    self.inner.source()
+    let rope = self.cache.source.get_or_init(|| {
+      #[allow(unsafe_code)]
+      // SAFETY: CachedSource guarantees that the underlying source outlives the cache,
+      // so transmuting Vec<&str> to Vec<&'static str> is safe in this context.
+      // This allows us to store string slices in the cache without additional allocations.
+      unsafe {
+        std::mem::transmute::<Vec<&str>, Vec<&'static str>>(self.rope())
+      }
+    });
+    SourceValue::String(Cow::Owned(rope.join("")))
+  }
+
+  fn rope(&self) -> Vec<&str> {
+    self.inner.rope()
   }
 
   fn buffer(&self) -> Cow<[u8]> {
@@ -114,10 +128,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,11 +167,19 @@ 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);
-      SourceValue::String(Cow::Owned(string))
+      SourceValue::String(Cow::Owned(self.rope().join("")))
+    }
+  }
+
+  fn rope(&self) -> Vec<&str> {
+    let children = self.optimized_children();
+    if children.len() == 1 {
+      children[0].rope()
+    } else {
+      children
+        .iter()
+        .flat_map(|child| child.rope())
+        .collect::<Vec<_>>()
     }
   }
 
@@ -206,12 +214,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

@@ -56,6 +56,10 @@ impl Source for OriginalSource {
     SourceValue::String(Cow::Borrowed(&self.value))
   }
 
+  fn rope(&self) -> Vec<&str> {
+    vec![self.value.as_ref()]
+  }
+
   fn buffer(&self) -> Cow<[u8]> {
     Cow::Borrowed(self.value.as_bytes())
   }
@@ -73,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

@@ -64,6 +64,10 @@ impl Source for RawStringSource {
     SourceValue::String(Cow::Borrowed(&self.0))
   }
 
+  fn rope(&self) -> Vec<&str> {
+    vec![self.0.as_ref()]
+  }
+
   fn buffer(&self) -> Cow<[u8]> {
     Cow::Borrowed(self.0.as_bytes())
   }
@@ -76,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())
   }
@@ -210,6 +210,10 @@ impl Source for RawBufferSource {
     SourceValue::Buffer(Cow::Borrowed(&self.value))
   }
 
+  fn rope(&self) -> Vec<&str> {
+    vec![self.get_or_init_value_as_string()]
+  }
+
   fn buffer(&self) -> Cow<[u8]> {
     Cow::Borrowed(&self.value)
   }
@@ -222,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

@@ -161,34 +161,150 @@ impl ReplaceSource {
 
 impl Source for ReplaceSource {
   fn source(&self) -> SourceValue {
-    let inner_source_code = self.inner.source().into_string_lossy();
+    let rope = self.rope();
+    if rope.len() == 1 {
+      SourceValue::String(Cow::Borrowed(rope[0]))
+    } else {
+      SourceValue::String(Cow::Owned(rope.join("")))
+    }
+  }
+
+  fn rope(&self) -> Vec<&str> {
+    let inner_source_code = self.inner.rope();
 
-    // mut_string_push_str is faster that vec join
-    // concatenate strings benchmark, see https://github.com/hoodie/concatenation_benchmarks-rs
     if self.replacements.is_empty() {
-      return SourceValue::String(inner_source_code);
+      return inner_source_code;
     }
-    let capacity = self.size();
-    let mut source_code = String::with_capacity(capacity);
-    let mut inner_pos = 0;
-    for replacement in &self.replacements {
-      if inner_pos < replacement.start {
-        let end_pos = (replacement.start as usize).min(inner_source_code.len());
-        source_code.push_str(&inner_source_code[inner_pos as usize..end_pos]);
+
+    let mut result = Vec::new();
+    let mut pos: u32 = 0;
+    let mut chunk_index = 0;
+    let mut chunk_pos = 0; // Position within current chunk
+    let mut replacement_index = 0;
+
+    // Calculate total length to determine positions
+    let mut chunk_start_positions = Vec::new();
+    let mut total_pos = 0;
+    for chunk in &inner_source_code {
+      chunk_start_positions.push(total_pos);
+      total_pos += chunk.len() as u32;
+    }
+
+    while replacement_index < self.replacements.len()
+      || chunk_index < inner_source_code.len()
+    {
+      let next_replacement = self.replacements.get(replacement_index);
+
+      // Process chunks until we hit a replacement or finish
+      while chunk_index < inner_source_code.len() {
+        let chunk = inner_source_code[chunk_index];
+        let chunk_start = chunk_start_positions[chunk_index];
+        let chunk_end = chunk_start + chunk.len() as u32;
+
+        // Check if there's a replacement that starts within this chunk
+        if let Some(replacement) = next_replacement {
+          if replacement.start >= chunk_start && replacement.start < chunk_end {
+            // Replacement starts within this chunk
+            let offset_in_chunk = (replacement.start - chunk_start) as usize;
+
+            // Add the part of chunk before replacement
+            if offset_in_chunk > chunk_pos {
+              result.push(&chunk[chunk_pos..offset_in_chunk]);
+            }
+
+            // Add replacement content
+            result.push(&replacement.content);
+
+            // Update positions
+            pos = replacement.end;
+            replacement_index += 1;
+
+            // Find where to continue after replacement
+            let mut found_continue_pos = false;
+            for (idx, &chunk_start_pos) in
+              chunk_start_positions.iter().enumerate()
+            {
+              let chunk_end_pos =
+                chunk_start_pos + inner_source_code[idx].len() as u32;
+
+              if pos >= chunk_start_pos && pos < chunk_end_pos {
+                // Continue from within this chunk
+                chunk_index = idx;
+                chunk_pos = (pos - chunk_start_pos) as usize;
+                found_continue_pos = true;
+                break;
+              } else if pos <= chunk_start_pos {
+                // Continue from the start of this chunk
+                chunk_index = idx;
+                chunk_pos = 0;
+                found_continue_pos = true;
+                break;
+              }
+            }
+
+            if !found_continue_pos {
+              // Replacement goes beyond all chunks
+              chunk_index = inner_source_code.len();
+            }
+
+            break;
+          } else if replacement.start < chunk_start {
+            // Replacement starts before this chunk
+            result.push(&replacement.content);
+            replacement_index += 1;
+
+            // Skip chunks that are replaced
+            pos = replacement.end;
+            while chunk_index < inner_source_code.len() {
+              let current_chunk_start = chunk_start_positions[chunk_index];
+              let current_chunk_end = current_chunk_start
+                + inner_source_code[chunk_index].len() as u32;
+
+              if pos <= current_chunk_start {
+                // Start from beginning of this chunk
+                chunk_pos = 0;
+                break;
+              } else if pos < current_chunk_end {
+                // Start from middle of this chunk
+                chunk_pos = (pos - current_chunk_start) as usize;
+                break;
+              } else {
+                // Skip this entire chunk
+                chunk_index += 1;
+              }
+            }
+            break;
+          }
+        }
+
+        // No replacement affecting this chunk, add the remaining part
+        if chunk_pos == 0
+          && (next_replacement.is_none()
+            || next_replacement.unwrap().start > chunk_end)
+        {
+          // Add entire chunk
+          result.push(chunk);
+        } else if chunk_pos < chunk.len() {
+          // Add remaining part of chunk
+          result.push(&chunk[chunk_pos..]);
+        }
+
+        chunk_index += 1;
+        chunk_pos = 0;
+        pos = chunk_end;
       }
-      source_code.push_str(&replacement.content);
-      #[allow(clippy::manual_clamp)]
-      {
-        inner_pos = inner_pos
-          .max(replacement.end)
-          .min(inner_source_code.len() as u32);
+
+      // Handle remaining replacements that are beyond all chunks
+      while replacement_index < self.replacements.len() {
+        let replacement = &self.replacements[replacement_index];
+        if replacement.start >= pos {
+          result.push(&replacement.content);
+        }
+        replacement_index += 1;
       }
     }
-    source_code.push_str(
-      &inner_source_code[inner_pos as usize..inner_source_code.len()],
-    );
 
-    SourceValue::String(Cow::Owned(source_code))
+    result
   }
 
   fn buffer(&self) -> Cow<[u8]> {
@@ -248,10 +364,6 @@ impl Source for ReplaceSource {
     get_map(&ObjectPool::default(), chunks.as_ref(), options)
   }
 
-  fn write_to_string(&self, string: &mut String) {
-    string.push_str(&self.source().into_string_lossy());
-  }
-
   fn to_writer(&self, writer: &mut dyn std::io::Write) -> std::io::Result<()> {
     writer.write_all(self.source().as_bytes())
   }

src/source.rs

@@ -114,6 +114,9 @@ pub trait Source:
   /// Get the source code.
   fn source(&self) -> SourceValue;
 
+  /// Return a lightweight "rope" view of the source as borrowed string slices.
+  fn rope(&self) -> Vec<&str>;
+
   /// Get the source buffer.
   fn buffer(&self) -> Cow<[u8]>;
 
@@ -132,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<()>;
 }
@@ -149,6 +144,10 @@ impl Source for BoxSource {
     self.as_ref().source()
   }
 
+  fn rope(&self) -> Vec<&str> {
+    self.as_ref().rope()
+  }
+
   fn buffer(&self) -> Cow<[u8]> {
     self.as_ref().buffer()
   }
@@ -165,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

@@ -94,6 +94,10 @@ impl Source for SourceMapSource {
     SourceValue::String(Cow::Borrowed(&self.value))
   }
 
+  fn rope(&self) -> Vec<&str> {
+    vec![self.value.as_ref()]
+  }
+
   fn buffer(&self) -> Cow<[u8]> {
     Cow::Borrowed(self.value.as_bytes())
   }
@@ -114,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())
   }