perf: try on_source

Author: SyMind

src/cached_source.rs

@@ -122,7 +122,7 @@ impl<T: Source + Hash + PartialEq + Eq + 'static> StreamChunks<'_>
   fn stream_chunks<'a>(
     &'a self,
     options: &MapOptions,
-    on_chunk: crate::helpers::OnChunk,
+    on_chunk: crate::helpers::OnChunk<'_, 'a>,
     on_source: crate::helpers::OnSource<'_, 'a>,
     on_name: crate::helpers::OnName<'_, 'a>,
   ) -> crate::helpers::GeneratedInfo {

src/concat_source.rs

@@ -149,7 +149,7 @@ impl<'a> StreamChunks<'a> for ConcatSource {
   fn stream_chunks(
     &'a self,
     options: &MapOptions,
-    on_chunk: OnChunk,
+    on_chunk: OnChunk<'_, 'a>,
     on_source: OnSource<'_, 'a>,
     on_name: OnName<'_, 'a>,
   ) -> crate::helpers::GeneratedInfo {

src/helpers.rs

@@ -70,14 +70,14 @@ pub trait StreamChunks<'a> {
   fn stream_chunks(
     &'a self,
     options: &MapOptions,
-    on_chunk: OnChunk,
+    on_chunk: OnChunk<'_, 'a>,
     on_source: OnSource<'_, 'a>,
     on_name: OnName<'_, 'a>,
   ) -> GeneratedInfo;
 }
 
 /// [OnChunk] abstraction, see [webpack-sources onChunk](https://github.com/webpack/webpack-sources/blob/9f98066311d53a153fdc7c633422a1d086528027/lib/helpers/streamChunks.js#L13).
-pub type OnChunk<'a> = &'a mut dyn FnMut(Option<&str>, Mapping);
+pub type OnChunk<'a, 'b> = &'a mut dyn FnMut(Option<&'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>);
@@ -90,7 +90,7 @@ pub fn stream_chunks_default<'a>(
   source: &'a str,
   source_map: Option<&'a SourceMap>,
   options: &MapOptions,
-  on_chunk: OnChunk,
+  on_chunk: OnChunk<'_, 'a>,
   on_source: OnSource<'_, 'a>,
   on_name: OnName<'_, 'a>,
 ) -> GeneratedInfo {
@@ -506,12 +506,12 @@ pub fn get_generated_source_info(source: &str) -> GeneratedInfo {
   }
 }
 
-pub fn stream_chunks_of_raw_source(
-  source: &str,
+pub fn stream_chunks_of_raw_source<'a>(
+  source: &'a str,
   options: &MapOptions,
-  on_chunk: OnChunk,
-  _on_source: OnSource,
-  _on_name: OnName,
+  on_chunk: OnChunk<'_, 'a>,
+  _on_source: OnSource<'_, 'a>,
+  _on_name: OnName<'_, 'a>,
 ) -> GeneratedInfo {
   if options.final_source {
     return get_generated_source_info(source);
@@ -549,7 +549,7 @@ pub fn stream_chunks_of_raw_source(
 pub fn stream_chunks_of_source_map<'a>(
   source: &'a str,
   source_map: &'a SourceMap,
-  on_chunk: OnChunk,
+  on_chunk: OnChunk<'_, 'a>,
   on_source: OnSource<'_, 'a>,
   on_name: OnName<'_, 'a>,
   options: &MapOptions,
@@ -651,7 +651,7 @@ fn stream_chunks_of_source_map_final<'a>(
 fn stream_chunks_of_source_map_full<'a>(
   source: &'a str,
   source_map: &'a SourceMap,
-  on_chunk: OnChunk,
+  on_chunk: OnChunk<'_, 'a>,
   on_source: OnSource<'_, 'a>,
   on_name: OnName<'_, 'a>,
 ) -> GeneratedInfo {
@@ -807,7 +807,7 @@ fn stream_chunks_of_source_map_lines_final<'a>(
 fn stream_chunks_of_source_map_lines_full<'a>(
   source: &'a str,
   source_map: &'a SourceMap,
-  on_chunk: OnChunk,
+  on_chunk: OnChunk<'_, 'a>,
   on_source: OnSource<'_, 'a>,
   _on_name: OnName,
 ) -> GeneratedInfo {
@@ -895,19 +895,19 @@ fn stream_chunks_of_source_map_lines_full<'a>(
 }
 
 #[derive(Debug)]
-struct SourceMapLineData {
+struct SourceMapLineData<'a> {
   pub mappings_data: Vec<i64>,
-  pub chunks: Vec<SourceMapLineChunk>,
+  pub chunks: Vec<SourceMapLineChunk<'a>>,
 }
 
 #[derive(Debug)]
-struct SourceMapLineChunk {
-  content: ArcStr,
-  cached: OnceCell<WithIndices<ArcStr>>,
+struct SourceMapLineChunk<'a> {
+  content: &'a str,
+  cached: OnceCell<WithIndices<&'a str>>,
 }
 
-impl SourceMapLineChunk {
-  pub fn new(content: ArcStr) -> Self {
+impl<'a> SourceMapLineChunk<'a> {
+  pub fn new(content: &'a str) -> Self {
     Self {
       content,
       cached: OnceCell::new(),
@@ -917,7 +917,7 @@ impl SourceMapLineChunk {
   pub fn substring(&self, start_index: usize, end_index: usize) -> &str {
     let cached = self
       .cached
-      .get_or_init(|| WithIndices::new(self.content.clone()));
+      .get_or_init(|| WithIndices::new(self.content));
     cached.substring(start_index, end_index)
   }
 }
@@ -930,14 +930,14 @@ pub fn stream_chunks_of_combined_source_map<'a>(
   inner_source: Option<&'a str>,
   inner_source_map: &'a SourceMap,
   remove_inner_source: bool,
-  on_chunk: OnChunk,
+  on_chunk: OnChunk<'_, 'a>,
   on_source: OnSource<'_, 'a>,
   on_name: OnName<'_, 'a>,
   options: &MapOptions,
 ) -> GeneratedInfo {
   let on_source = RefCell::new(on_source);
-  let inner_source: RefCell<Option<&'a str>> = RefCell::new(inner_source);
-  let source_mapping: RefCell<HashMap<ArcStr, u32>> =
+  let inner_source: RefCell<Option<&str>> = RefCell::new(inner_source);
+  let source_mapping: RefCell<HashMap<String, u32>> =
     RefCell::new(HashMap::default());
   let mut name_mapping: HashMap<&str, u32> = HashMap::default();
   let source_index_mapping: RefCell<HashMap<i64, i64>> =
@@ -950,9 +950,9 @@ pub fn stream_chunks_of_combined_source_map<'a>(
   let inner_source_index_mapping: RefCell<HashMap<i64, i64>> =
     RefCell::new(HashMap::default());
   let inner_source_index_value_mapping: RefCell<
-    HashMap<i64, (ArcStr, Option<&'a str>)>,
+    HashMap<i64, (String, Option<&str>)>,
   > = RefCell::new(HashMap::default());
-  let inner_source_contents: RefCell<HashMap<i64, Option<ArcStr>>> =
+  let inner_source_contents: RefCell<HashMap<i64, Option<&str>>> =
     RefCell::new(HashMap::default());
   let inner_source_content_lines: InnerSourceContentLine =
     RefCell::new(HashMap::default());
@@ -1083,10 +1083,10 @@ pub fn stream_chunks_of_combined_source_map<'a>(
                 .cloned()
                 .unwrap_or(("".into(), None));
               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.to_string()).copied();
               if global_index.is_none() {
                 let len = source_mapping.len() as u32;
-                source_mapping.insert(source.clone(), len);
+                source_mapping.insert(source.to_string(), len);
                 on_source.borrow_mut()(len, &source, source_content);
                 global_index = Some(len);
               }
@@ -1363,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.into(), source_content.map(Into::into)));
+              .insert(i, (source.to_string(), source_content));
           },
           &mut |i, name| {
             let i = i as i64;
@@ -1380,7 +1380,7 @@ pub fn stream_chunks_of_combined_source_map<'a>(
         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.into(), len);
+          source_mapping.insert(source.to_string(), len);
           on_source.borrow_mut()(len, source, source_content);
           global_index = Some(len);
         }
@@ -1401,7 +1401,7 @@ pub fn stream_chunks_of_combined_source_map<'a>(
 pub fn stream_and_get_source_and_map<'a, S: StreamChunks<'a>>(
   input_source: &'a S,
   options: &MapOptions,
-  on_chunk: OnChunk,
+  on_chunk: OnChunk<'_, 'a>,
   on_source: OnSource<'_, 'a>,
   on_name: OnName<'_, 'a>,
 ) -> (GeneratedInfo, Option<SourceMap>) {

src/original_source.rs

@@ -102,7 +102,7 @@ impl<'a> StreamChunks<'a> for OriginalSource {
   fn stream_chunks(
     &'a self,
     options: &MapOptions,
-    on_chunk: OnChunk,
+    on_chunk: OnChunk<'_, 'a>,
     on_source: OnSource<'_, 'a>,
     _on_name: OnName,
   ) -> crate::helpers::GeneratedInfo {

src/raw_source.rs

@@ -1,6 +1,6 @@
 use std::{
   borrow::Cow,
-  hash::{Hash, Hasher},
+  hash::{Hash, Hasher}, sync::OnceLock,
 };
 
 use crate::{
@@ -27,15 +27,15 @@ use crate::{
 #[derive(Clone, Eq)]
 pub enum RawSource {
   /// Represent buffer.
-  Buffer(Vec<u8>),
+  Buffer(Vec<u8>, OnceLock<String>),
   /// Represent string.
   Source(String),
 }
 
 impl RawSource {
   /// Whether the [RawSource] represent a buffer.
   pub fn is_buffer(&self) -> bool {
-    matches!(self, Self::Buffer(_))
+    matches!(self, Self::Buffer(_, _))
   }
 }
 
@@ -47,7 +47,7 @@ impl From<String> for RawSource {
 
 impl From<Vec<u8>> for RawSource {
   fn from(s: Vec<u8>) -> Self {
-    Self::Buffer(s)
+    Self::Buffer(s, OnceLock::new())
   }
 }
 
@@ -59,28 +59,28 @@ impl From<&str> for RawSource {
 
 impl From<&[u8]> for RawSource {
   fn from(s: &[u8]) -> Self {
-    Self::Buffer(s.to_owned())
+    Self::Buffer(s.to_owned(), OnceLock::new())
   }
 }
 
 impl Source for RawSource {
   fn source(&self) -> Cow<str> {
     match self {
-      RawSource::Buffer(i) => String::from_utf8_lossy(i),
+      RawSource::Buffer(i, _) => String::from_utf8_lossy(i),
       RawSource::Source(i) => Cow::Borrowed(i),
     }
   }
 
   fn buffer(&self) -> Cow<[u8]> {
     match self {
-      RawSource::Buffer(i) => Cow::Borrowed(i),
+      RawSource::Buffer(i, _) => Cow::Borrowed(i),
       RawSource::Source(i) => Cow::Borrowed(i.as_bytes()),
     }
   }
 
   fn size(&self) -> usize {
     match self {
-      RawSource::Buffer(i) => i.len(),
+      RawSource::Buffer(i, _) => i.len(),
       RawSource::Source(i) => i.len(),
     }
   }
@@ -91,7 +91,7 @@ impl Source for RawSource {
 
   fn to_writer(&self, writer: &mut dyn std::io::Write) -> std::io::Result<()> {
     writer.write_all(match self {
-      RawSource::Buffer(i) => i,
+      RawSource::Buffer(i, _) => i,
       RawSource::Source(i) => i.as_bytes(),
     })
   }
@@ -107,7 +107,7 @@ impl Hash for RawSource {
 impl PartialEq for RawSource {
   fn eq(&self, other: &Self) -> bool {
     match (self, other) {
-      (Self::Buffer(l0), Self::Buffer(r0)) => l0 == r0,
+      (Self::Buffer(l0, _), Self::Buffer(r0, _)) => l0 == r0,
       (Self::Source(l0), Self::Source(r0)) => l0 == r0,
       _ => false,
     }
@@ -121,7 +121,7 @@ impl std::fmt::Debug for RawSource {
   ) -> Result<(), std::fmt::Error> {
     let mut d = f.debug_struct("RawSource");
     match self {
-      Self::Buffer(buffer) => {
+      Self::Buffer(buffer, _) => {
         d.field(
           "buffer",
           &buffer.iter().take(50).copied().collect::<Vec<u8>>(),
@@ -135,24 +135,32 @@ impl std::fmt::Debug for RawSource {
   }
 }
 
-impl StreamChunks<'_> for RawSource {
+impl<'a> StreamChunks<'a> for RawSource {
   fn stream_chunks(
-    &self,
+    &'a self,
     options: &MapOptions,
-    on_chunk: OnChunk,
-    on_source: OnSource,
-    on_name: OnName,
+    on_chunk: OnChunk<'_, 'a>,
+    on_source: OnSource<'_, 'a>,
+    on_name: OnName<'_, 'a>,
   ) -> crate::helpers::GeneratedInfo {
     if options.final_source {
       get_generated_source_info(&self.source())
     } else {
-      stream_chunks_of_raw_source(
-        &self.source(),
-        options,
-        on_chunk,
-        on_source,
-        on_name,
-      )
+      match &self {
+        RawSource::Buffer(buffer, value_as_string) => {
+          let source = value_as_string.get_or_init(|| {
+            String::from_utf8_lossy(&buffer).to_string()
+          });
+          stream_chunks_of_raw_source(
+            source,
+            options,
+            on_chunk,
+            on_source,
+            on_name,
+          )
+        },
+        RawSource::Source(_) => todo!(),
+      }
     }
   }
 }