perf: memory pool

Author: SyMind

src/cached_source.rs

@@ -301,10 +301,7 @@ mod tests {
 
   #[test]
   fn should_produce_correct_output_for_cached_raw_source() {
-    let map_options = MapOptions {
-      columns: true,
-      final_source: true,
-    };
+    let map_options = MapOptions::new(true);
 
     let source = RawStringSource::from("Test\nTest\nTest\n");
     let mut on_chunk_count = 0;

src/helpers.rs

@@ -2,18 +2,13 @@ use std::{
   borrow::{BorrowMut, Cow},
   cell::{OnceCell, RefCell},
   marker::PhantomData,
-  ops::Range,
+  ops::Range, rc::Rc,
 };
 
 use rustc_hash::FxHashMap as HashMap;
 
 use crate::{
-  decoder::MappingsDecoder,
-  encoder::create_encoder,
-  linear_map::LinearMap,
-  source::{Mapping, OriginalLocation},
-  with_indices::WithIndices,
-  MapOptions, Rope, SourceMap,
+  decoder::MappingsDecoder, encoder::create_encoder, linear_map::LinearMap, source::{Mapping, OriginalLocation}, with_indices::WithIndices, work_context::{self, WorkContext}, MapOptions, Rope, SourceMap
 };
 
 // Adding this type because sourceContentLine not happy
@@ -33,6 +28,7 @@ pub fn get_map<'a, S: StreamChunks>(
     &MapOptions {
       columns: options.columns,
       final_source: true,
+      work_context: options.work_context.clone(),
     },
     // on_chunk
     &mut |_, mapping| {
@@ -317,24 +313,28 @@ where
     MapOptions {
       columns: true,
       final_source: true,
+      ..
     } => stream_chunks_of_source_map_final(
       source, source_map, on_chunk, on_source, on_name,
     ),
     MapOptions {
       columns: true,
       final_source: false,
+      work_context
     } => stream_chunks_of_source_map_full(
-      source, source_map, on_chunk, on_source, on_name,
+      work_context.clone(), source, source_map, on_chunk, on_source, on_name,
     ),
     MapOptions {
       columns: false,
       final_source: true,
+      ..
     } => stream_chunks_of_source_map_lines_final(
       source, source_map, on_chunk, on_source, on_name,
     ),
     MapOptions {
       columns: false,
       final_source: false,
+      ..
     } => stream_chunks_of_source_map_lines_full(
       source, source_map, on_chunk, on_source, on_name,
     ),
@@ -413,6 +413,7 @@ where
 }
 
 fn stream_chunks_of_source_map_full<'a, S>(
+  work_context: Rc<WorkContext>,
   source: S,
   source_map: &'a SourceMap,
   on_chunk: OnChunk<'_, 'a>,
@@ -423,7 +424,7 @@ where
   S: SourceText<'a> + 'a,
 {
   let lines = split_into_lines(&source);
-  let line_with_indices_list = lines.map(WithIndices::new).collect::<Vec<_>>();
+  let line_with_indices_list = lines.map(|line| WithIndices::new(work_context.clone(), line)).collect::<Vec<_>>();
 
   if line_with_indices_list.is_empty() {
     return GeneratedInfo {
@@ -710,6 +711,7 @@ type InnerSourceIndexValueMapping<'a> =
 
 #[allow(clippy::too_many_arguments)]
 pub fn stream_chunks_of_combined_source_map<'a, S>(
+  work_context: Rc<WorkContext>,
   source: S,
   source_map: &'a SourceMap,
   inner_source_name: &'a str,
@@ -830,7 +832,7 @@ where
                     match inner_source_contents.get(&inner_source_index) {
                       Some(Some(source_content)) => Some(
                         split_into_lines(source_content)
-                          .map(WithIndices::new)
+                          .map(|line| WithIndices::new(work_context.clone(), line))
                           .collect(),
                       ),
                       _ => None,
@@ -930,7 +932,7 @@ where
                     match inner_source_contents.get(&inner_source_index) {
                       Some(Some(source_content)) => Some(
                         split_into_lines(source_content)
-                          .map(WithIndices::new)
+                          .map(|line| WithIndices::new(work_context.clone(), line))
                           .collect(),
                       ),
                       _ => None,
@@ -1167,6 +1169,7 @@ where
           &MapOptions {
             columns: options.columns,
             final_source: false,
+            work_context: options.work_context.clone(),
           },
         );
       } else {

src/lib.rs

@@ -14,6 +14,7 @@ mod rope;
 mod source;
 mod source_map_source;
 mod with_indices;
+mod work_context;
 
 pub use cached_source::CachedSource;
 pub use concat_source::ConcatSource;

src/replace_source.rs

@@ -391,7 +391,7 @@ impl StreamChunks for ReplaceSource {
           match source_content {
             SourceContent::Raw(source) => {
               let lines = split_into_lines(source)
-                .map(WithIndices::new)
+                .map(|line| WithIndices::new(options.work_context.clone(), line))
                 .collect::<Vec<_>>();
               let matched =
                 check_content_at_position(&lines, line, column, expected_chunk);
@@ -411,6 +411,7 @@ impl StreamChunks for ReplaceSource {
       &MapOptions {
         columns: options.columns,
         final_source: false,
+        work_context: options.work_context.clone()
       },
       &mut |chunk, mut mapping| {
         // SAFETY: final_source is false in ReplaceSource

src/source.rs

@@ -1,19 +1,12 @@
 use std::{
-  any::{Any, TypeId},
-  borrow::Cow,
-  convert::{TryFrom, TryInto},
-  fmt,
-  hash::{Hash, Hasher},
-  sync::Arc,
+  any::{Any, TypeId}, borrow::Cow, collections::BinaryHeap, convert::{TryFrom, TryInto}, fmt, hash::{Hash, Hasher}, rc::Rc, sync::Arc
 };
 
 use dyn_clone::DynClone;
 use serde::{Deserialize, Serialize};
 
 use crate::{
-  helpers::{decode_mappings, StreamChunks},
-  rope::Rope,
-  Result,
+  helpers::{decode_mappings, StreamChunks}, rope::Rope, work_context::WorkContext, Result
 };
 
 /// An alias for `Box<dyn Source>`.
@@ -250,19 +243,36 @@ impl<T: Source + 'static> SourceExt for T {
 }
 
 /// Options for [Source::map].
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone)]
 pub struct MapOptions {
   /// Whether have columns info in generated [SourceMap] mappings.
   pub columns: bool,
   /// Whether the source will have changes, internal used for `ReplaceSource`, etc.
   pub(crate) final_source: bool,
+  pub(crate) work_context: Rc<WorkContext>,
+}
+
+impl PartialEq for MapOptions {
+  fn eq(&self, other: &Self) -> bool {
+    self.columns == other.columns && self.final_source == other.final_source
+  }
+}
+
+impl Eq for MapOptions {}
+
+impl Hash for MapOptions {
+  fn hash<H: Hasher>(&self, state: &mut H) {
+    self.columns.hash(state);
+    self.final_source.hash(state);
+  }
 }
 
 impl Default for MapOptions {
   fn default() -> Self {
     Self {
       columns: true,
       final_source: false,
+      work_context: Default::default()
     }
   }
 }

src/source_map_source.rs

@@ -191,6 +191,7 @@ impl StreamChunks for SourceMapSource {
   ) -> crate::helpers::GeneratedInfo {
     if let Some(inner_source_map) = &self.inner_source_map {
       stream_chunks_of_combined_source_map(
+        options.work_context.clone(),
         &*self.value,
         &self.source_map,
         &self.name,
@@ -469,10 +470,7 @@ mod tests {
       .into_string_lossy()
       .into_owned());
     test_cached!(source, |s: &dyn Source| s.map(&MapOptions::default()));
-    test_cached!(source, |s: &dyn Source| s.map(&MapOptions {
-      columns: false,
-      final_source: true
-    }));
+    test_cached!(source, |s: &dyn Source| s.map(&MapOptions::new(false)));
   }
 
   #[test]

src/with_indices.rs

@@ -1,27 +1,29 @@
-use std::{cell::OnceCell, marker::PhantomData};
+use std::{cell::OnceCell, marker::PhantomData, rc::Rc};
 
-use crate::helpers::SourceText;
+use crate::{helpers::SourceText, work_context::{PooledVec, WorkContext}};
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct WithIndices<'a, S>
 where
   S: SourceText<'a>,
 {
   /// line is a string reference
   pub line: S,
   /// the byte position of each `char` in `line` string slice .
-  pub indices_indexes: OnceCell<Vec<usize>>,
+  pub indices_indexes: OnceCell<PooledVec>,
+  work_context: Rc<WorkContext>,
   data: PhantomData<&'a S>,
 }
 
 impl<'a, S> WithIndices<'a, S>
 where
   S: SourceText<'a>,
 {
-  pub fn new(line: S) -> Self {
+  pub fn new(work_context: Rc<WorkContext>, line: S) -> Self {
     Self {
       indices_indexes: OnceCell::new(),
       line,
+      work_context,
       data: PhantomData,
     }
   }
@@ -32,8 +34,12 @@ where
       return S::default();
     }
 
-    let indices_indexes = self.indices_indexes.get_or_init(|| {
-      self.line.char_indices().map(|(i, _)| i).collect::<Vec<_>>()
+    let indices_indexes = &*self.indices_indexes.get_or_init(|| {
+      let mut vec = PooledVec::new(self.work_context.clone(), self.line.len());
+      for (i, _) in self.line.char_indices() {
+        vec.push(i);
+      }
+      vec
     });
 
     let str_len = self.line.len();
@@ -53,40 +59,42 @@ where
 /// tests are just copy from `substring` crate
 #[cfg(test)]
 mod tests {
-  use crate::Rope;
+  use std::rc::Rc;
+
+use crate::{work_context::WorkContext, Rope};
 
   use super::WithIndices;
   #[test]
   fn test_substring() {
     assert_eq!(
-      WithIndices::new(Rope::from("foobar")).substring(0, 3),
+      WithIndices::new(Rc::new(WorkContext::default()), Rope::from("foobar")).substring(0, 3),
       "foo"
     );
   }
 
   #[test]
   fn test_out_of_bounds() {
     assert_eq!(
-      WithIndices::new(Rope::from("foobar")).substring(0, 10),
+      WithIndices::new(Rc::new(WorkContext::default()), Rope::from("foobar")).substring(0, 10),
       "foobar"
     );
-    assert_eq!(WithIndices::new(Rope::from("foobar")).substring(6, 10), "");
+    assert_eq!(WithIndices::new(Rc::new(WorkContext::default()), Rope::from("foobar")).substring(6, 10), "");
   }
 
   #[test]
   fn test_start_less_than_end() {
-    assert_eq!(WithIndices::new(Rope::from("foobar")).substring(3, 2), "");
+    assert_eq!(WithIndices::new(Rc::new(WorkContext::default()), Rope::from("foobar")).substring(3, 2), "");
   }
 
   #[test]
   fn test_start_and_end_equal() {
-    assert_eq!(WithIndices::new(Rope::from("foobar")).substring(3, 3), "");
+    assert_eq!(WithIndices::new(Rc::new(WorkContext::default()), Rope::from("foobar")).substring(3, 3), "");
   }
 
   #[test]
   fn test_multiple_byte_characters() {
     assert_eq!(
-      WithIndices::new(Rope::from("fõøbα®")).substring(2, 5),
+      WithIndices::new(Rc::new(WorkContext::default()), Rope::from("fõøbα®")).substring(2, 5),
       "øbα"
     );
   }