fix: perf bug for large replace source (#156)

Author: SyMind

benches/bench.rs

@@ -1,5 +1,7 @@
 #![allow(missing_docs)]
 
+mod bench_complex_replace_source;
+
 use std::collections::HashMap;
 
 #[cfg(not(codspeed))]
@@ -9,10 +11,12 @@ pub use criterion::*;
 pub use codspeed_criterion_compat::*;
 
 use rspack_sources::{
-  BoxSource, CachedSource, ConcatSource, MapOptions, ReplaceSource, Source,
-  SourceExt, SourceMap, SourceMapSource, SourceMapSourceOptions,
+  BoxSource, CachedSource, ConcatSource, MapOptions, Source, SourceExt,
+  SourceMap, SourceMapSource, SourceMapSourceOptions,
 };
 
+use bench_complex_replace_source::benchmark_complex_replace_source;
+
 const HELLOWORLD_JS: &str = include_str!(concat!(
   env!("CARGO_MANIFEST_DIR"),
   "/benches/fixtures/transpile-minify/files/helloworld.js"
@@ -164,39 +168,6 @@ fn benchmark_concat_generate_base64_with_cache(b: &mut Bencher) {
   })
 }
 
-fn benchmark_replace_large_minified_source(b: &mut Bencher) {
-  let antd_minify = SourceMapSource::new(SourceMapSourceOptions {
-    value: ANTD_MIN_JS,
-    name: "antd.min.js",
-    source_map: SourceMap::from_json(ANTD_MIN_JS_MAP).unwrap(),
-    original_source: None,
-    inner_source_map: None,
-    remove_original_source: false,
-  });
-  let mut replace_source = ReplaceSource::new(antd_minify);
-  replace_source.replace(107, 114, "exports", None);
-  replace_source.replace(130, 143, "'object'", None);
-  replace_source.replace(165, 172, "__webpack_require__", None);
-  replace_source.replace(173, 180, "/*! react */\"./node_modules/.pnpm/react@18.2.0/node_modules/react/index.js\"", None);
-  replace_source.replace(183, 190, "__webpack_require__", None);
-  replace_source.replace(191, 202, "/*! react-dom */\"./node_modules/.pnpm/react-dom@18.2.0_react@18.2.0/node_modules/react-dom/index.js\"", None);
-  replace_source.replace(205, 212, "__webpack_require__", None);
-  replace_source.replace(213, 220, "/*! dayjs */\"./node_modules/.pnpm/dayjs@1.11.10/node_modules/dayjs/dayjs.min.js\"", None);
-  replace_source.replace(363, 370, "exports", None);
-  replace_source.replace(373, 385, "exports.antd", None);
-  replace_source.replace(390, 397, "__webpack_require__", None);
-  replace_source.replace(398, 405, "/*! react */\"./node_modules/.pnpm/react@18.2.0/node_modules/react/index.js\"", None);
-  replace_source.replace(408, 415, "__webpack_require__", None);
-  replace_source.replace(416, 427, "/*! react-dom */\"./node_modules/.pnpm/react-dom@18.2.0_react@18.2.0/node_modules/react-dom/index.js\"", None);
-  replace_source.replace(430, 437, "__webpack_require__", None);
-  replace_source.replace(438, 445, "/*! dayjs */\"./node_modules/.pnpm/dayjs@1.11.10/node_modules/dayjs/dayjs.min.js\"", None);
-  replace_source.replace(494, 498, "this", None);
-
-  b.iter(|| {
-    replace_source.map(&MapOptions::default());
-  });
-}
-
 fn benchmark_concat_generate_string_with_cache_as_key(b: &mut Bencher) {
   let sms_minify = SourceMapSource::new(SourceMapSourceOptions {
     value: HELLOWORLD_MIN_JS,
@@ -260,16 +231,14 @@ fn bench_rspack_sources(criterion: &mut Criterion) {
   );
   group
     .bench_function("concat_generate_base64", benchmark_concat_generate_base64);
+
   group.bench_function(
     "concat_generate_string_with_cache",
     benchmark_concat_generate_string_with_cache,
   );
   group
     .bench_function("concat_generate_string", benchmark_concat_generate_string);
-  group.bench_function(
-    "replace_large_minified_source",
-    benchmark_replace_large_minified_source,
-  );
+
   group.bench_function(
     "concat_generate_string_with_cache_as_key",
     benchmark_concat_generate_string_with_cache_as_key,
@@ -278,6 +247,10 @@ fn bench_rspack_sources(criterion: &mut Criterion) {
     "concat_generate_string_as_key",
     benchmark_concat_generate_string_as_key,
   );
+
+  group
+    .bench_function("complex_replace_source", benchmark_complex_replace_source);
+
   group.finish();
 }
 

benches/bench_complex_replace_source.rs

@@ -185,11 +185,17 @@ impl<T: std::fmt::Debug> std::fmt::Debug for CachedSource<T> {
     &self,
     f: &mut std::fmt::Formatter<'_>,
   ) -> Result<(), std::fmt::Error> {
-    f.debug_struct("CachedSource")
-      .field("inner", self.inner.as_ref())
-      .field("cached_hash", self.cached_hash.as_ref())
-      .field("cached_maps", &(!self.cached_maps.is_empty()))
-      .finish()
+    let indent = f.width().unwrap_or(0);
+    let indent_str = format!("{:indent$}", "", indent = indent);
+
+    writeln!(f, "{indent_str}CachedSource::new(")?;
+    writeln!(
+      f,
+      "{indent_str}{:indent$?}",
+      self.inner,
+      indent = indent + 2
+    )?;
+    write!(f, "{indent_str}).boxed()")
   }
 }
 

src/cached_source.rs

@@ -55,11 +55,24 @@ use crate::{
 ///   .unwrap()
 /// );
 /// ```
-#[derive(Debug, Default, Clone)]
+#[derive(Default, Clone)]
 pub struct ConcatSource {
   children: Vec<BoxSource>,
 }
 
+impl std::fmt::Debug for ConcatSource {
+  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    let indent = f.width().unwrap_or(0);
+    let indent_str = format!("{:indent$}", "", indent = indent);
+
+    writeln!(f, "{indent_str}ConcatSource::new(vec![")?;
+    for child in self.children.iter() {
+      writeln!(f, "{:indent$?},", child, indent = indent + 2)?;
+    }
+    write!(f, "{indent_str}]).boxed()")
+  }
+}
+
 impl ConcatSource {
   /// Create a [ConcatSource] with [Source]s.
   pub fn new<S, T>(sources: S) -> Self

src/concat_source.rs

@@ -95,10 +95,13 @@ impl std::fmt::Debug for OriginalSource {
     &self,
     f: &mut std::fmt::Formatter<'_>,
   ) -> Result<(), std::fmt::Error> {
-    f.debug_struct("OriginalSource")
-      .field("name", &self.name)
-      .field("value", &self.value.chars().take(50).collect::<String>())
-      .finish()
+    let indent = f.width().unwrap_or(0);
+    let indent_str = format!("{:indent$}", "", indent = indent);
+
+    writeln!(f, "{indent_str}OriginalSource::new(")?;
+    writeln!(f, "{indent_str}  {:?},", self.value)?;
+    writeln!(f, "{indent_str}  {:?},", self.name)?;
+    write!(f, "{indent_str}).boxed()")
   }
 }
 

src/original_source.rs

@@ -182,19 +182,22 @@ impl std::fmt::Debug for RawSource {
     &self,
     f: &mut std::fmt::Formatter<'_>,
   ) -> Result<(), std::fmt::Error> {
-    let mut d = f.debug_struct("RawSource");
-    match &self.value {
-      RawValue::Buffer(buffer) => {
-        d.field(
-          "buffer",
-          &buffer.iter().take(50).copied().collect::<Vec<u8>>(),
-        );
-      }
-      RawValue::String(string) => {
-        d.field("source", &string.chars().take(50).collect::<String>());
-      }
+    let indent = f.width().unwrap_or(0);
+    let indent_str = format!("{:indent$}", "", indent = indent);
+
+    if self.is_buffer() {
+      write!(
+        f,
+        "{indent_str}RawSource::from({:?}).boxed()",
+        self.buffer()
+      )
+    } else {
+      write!(
+        f,
+        "{indent_str}RawSource::from_static({:?}).boxed()",
+        self.source()
+      )
     }
-    d.finish()
   }
 }
 
@@ -311,9 +314,13 @@ impl std::fmt::Debug for RawStringSource {
     &self,
     f: &mut std::fmt::Formatter<'_>,
   ) -> Result<(), std::fmt::Error> {
-    let mut d = f.debug_tuple("RawStringSource");
-    d.field(&self.0.chars().take(50).collect::<String>());
-    d.finish()
+    let indent = f.width().unwrap_or(0);
+    let indent_str = format!("{:indent$}", "", indent = indent);
+    write!(
+      f,
+      "{indent_str}RawStringSource::from_static({:?}).boxed()",
+      self.0.as_ref()
+    )
   }
 }
 
@@ -418,9 +425,13 @@ impl std::fmt::Debug for RawBufferSource {
     &self,
     f: &mut std::fmt::Formatter<'_>,
   ) -> Result<(), std::fmt::Error> {
-    let mut d = f.debug_tuple("RawBufferSource");
-    d.field(&self.value.iter().take(50).copied().collect::<Vec<u8>>());
-    d.finish()
+    let indent = f.width().unwrap_or(0);
+    let indent_str = format!("{:indent$}", "", indent = indent);
+    write!(
+      f,
+      "{indent_str}RawBufferSource::from({:?}).boxed()",
+      self.value
+    )
   }
 }
 

src/raw_source.rs

@@ -17,6 +17,7 @@ use crate::{
   },
   linear_map::LinearMap,
   rope::Rope,
+  with_indices::WithIndices,
   MapOptions, Mapping, OriginalLocation, Source, SourceMap,
 };
 
@@ -282,40 +283,58 @@ impl<T: std::fmt::Debug> std::fmt::Debug for ReplaceSource<T> {
     &self,
     f: &mut std::fmt::Formatter<'_>,
   ) -> Result<(), std::fmt::Error> {
-    f.debug_struct("ReplaceSource")
-      .field("inner", self.inner.as_ref())
-      .field(
-        "replacements",
-        &self.replacements.iter().take(3).collect::<Vec<_>>(),
-      )
-      .field("is_sorted", &self.is_sorted.load(Ordering::SeqCst))
-      .finish()
+    let indent = f.width().unwrap_or(0);
+    let indent_str = format!("{:indent$}", "", indent = indent);
+
+    writeln!(f, "{indent_str}{{")?;
+    writeln!(f, "{indent_str}  let mut source = ReplaceSource::new(")?;
+    writeln!(f, "{:indent$?}", &self.inner, indent = indent + 4)?;
+    writeln!(f, "{indent_str}  );")?;
+    for repl in self.sorted_replacement() {
+      match repl.enforce {
+        ReplacementEnforce::Pre => {
+          writeln!(
+            f,
+            "{indent_str}  source.replace_with_enforce({:#?}, {:#?}, {:#?}, {:#?}, ReplacementEnforce::Pre);",
+            repl.start, repl.end, repl.content, repl.name
+          )?;
+        }
+        ReplacementEnforce::Normal => {
+          writeln!(
+            f,
+            "{indent_str}  source.replace({:#?}, {:#?}, {:#?}, {:#?});",
+            repl.start, repl.end, repl.content, repl.name
+          )?;
+        }
+        ReplacementEnforce::Post => {
+          writeln!(
+            f,
+            "{indent_str}  source.replace_with_enforce({:#?}, {:#?}, {:#?}, {:#?}, ReplacementEnforce::Post);",
+            repl.start, repl.end, repl.content, repl.name
+          )?;
+        }
+      }
+    }
+    writeln!(f, "{indent_str}  source.boxed()")?;
+    write!(f, "{indent_str}}}")
   }
 }
 
 enum SourceContent<'a> {
   Raw(Rope<'a>),
-  Lines(Vec<Rope<'a>>),
+  Lines(Vec<WithIndices<'a, Rope<'a>>>),
 }
 
-fn check_content_at_position(
-  lines: &[Rope],
+fn check_content_at_position<'a>(
+  lines: &[WithIndices<'a, Rope<'a>>],
   line: u32,
   column: u32,
   expected: Rope, // FIXME: memory
 ) -> bool {
   if let Some(line) = lines.get(line as usize - 1) {
-    match line
-      .char_indices()
-      .nth(column as usize)
-      .map(|(byte_index, _)| byte_index)
-    {
-      Some(byte_index) => {
-        line.get_byte_slice(byte_index..byte_index + expected.len())
-          == Some(expected)
-      }
-      None => false,
-    }
+    line
+      .substring(column as usize, usize::MAX)
+      .starts_with(&expected)
   } else {
     false
   }
@@ -378,7 +397,9 @@ impl<T: Source> StreamChunks for ReplaceSource<T> {
         {
           match source_content {
             SourceContent::Raw(source) => {
-              let lines = split_into_lines(source).collect::<Vec<_>>();
+              let lines = split_into_lines(source)
+                .map(WithIndices::new)
+                .collect::<Vec<_>>();
               let matched =
                 check_content_at_position(&lines, line, column, expected_chunk);
               *source_content = SourceContent::Lines(lines);
@@ -1220,4 +1241,26 @@ return <div>{data.foo}</div>
     source2.replace(18, 19, "))", None);
     assert_eq!(source2.source(), "export default foo)));aaa");
   }
+
+  #[test]
+  fn debug() {
+    let mut source =
+      ReplaceSource::new(OriginalSource::new("hello", "file.txt").boxed());
+    source.replace(0, 0, "println!(\"", None);
+    source.replace(5, 5, "\")", None);
+    assert_eq!(
+      format!("{:?}", source),
+      r#"{
+  let mut source = ReplaceSource::new(
+    OriginalSource::new(
+      "hello",
+      "file.txt",
+    ).boxed()
+  );
+  source.replace(0, 0, "println!(\"", None);
+  source.replace(5, 5, "\")", None);
+  source.boxed()
+}"#
+    );
+  }
 }