cargo fmt

Author: SyMind

src/helpers.rs

@@ -2,18 +2,26 @@ use std::{
   borrow::{BorrowMut, Cow},
   cell::{OnceCell, RefCell},
   marker::PhantomData,
-  ops::Range, rc::Rc,
+  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, work_context::{self, WorkContext}, MapOptions, Rope, SourceMap
+  decoder::MappingsDecoder,
+  encoder::create_encoder,
+  linear_map::LinearMap,
+  source::{Mapping, OriginalLocation},
+  with_indices::WithIndices,
+  work_context::WorkContext,
+  MapOptions, Rope, SourceMap,
 };
 
 // Adding this type because sourceContentLine not happy
-type InnerSourceContentLine<'a, 'b> =
-  RefCell<LinearMap<OnceCell<Option<Vec<WithIndices<'a, Rope<'b>>>>>>>;
+type InnerSourceContentLine<'context, 'text> = RefCell<
+  LinearMap<OnceCell<Option<Vec<WithIndices<'context, 'text, Rope<'text>>>>>>,
+>;
 
 pub fn get_map<'a, S: StreamChunks>(
   stream: &'a S,
@@ -320,9 +328,14 @@ where
     MapOptions {
       columns: true,
       final_source: false,
-      work_context
+      work_context,
     } => stream_chunks_of_source_map_full(
-      work_context.clone(), source, source_map, on_chunk, on_source, on_name,
+      work_context.clone(),
+      source,
+      source_map,
+      on_chunk,
+      on_source,
+      on_name,
     ),
     MapOptions {
       columns: false,
@@ -424,7 +437,9 @@ where
   S: SourceText<'a> + 'a,
 {
   let lines = split_into_lines(&source);
-  let line_with_indices_list = lines.map(|line| WithIndices::new(work_context.clone(), line)).collect::<Vec<_>>();
+  let line_with_indices_list = lines
+    .map(|line| WithIndices::new(work_context.as_ref(), line))
+    .collect::<Vec<_>>();
 
   if line_with_indices_list.is_empty() {
     return GeneratedInfo {
@@ -832,7 +847,9 @@ where
                     match inner_source_contents.get(&inner_source_index) {
                       Some(Some(source_content)) => Some(
                         split_into_lines(source_content)
-                          .map(|line| WithIndices::new(work_context.clone(), line))
+                          .map(|line| {
+                            WithIndices::new(work_context.as_ref(), line)
+                          })
                           .collect(),
                       ),
                       _ => None,
@@ -932,7 +949,9 @@ where
                     match inner_source_contents.get(&inner_source_index) {
                       Some(Some(source_content)) => Some(
                         split_into_lines(source_content)
-                          .map(|line| WithIndices::new(work_context.clone(), line))
+                          .map(|line| {
+                            WithIndices::new(work_context.as_ref(), line)
+                          })
                           .collect(),
                       ),
                       _ => None,

src/replace_source.rs

@@ -313,13 +313,13 @@ impl std::fmt::Debug for ReplaceSource {
   }
 }
 
-enum SourceContent<'a> {
-  Raw(Rope<'a>),
-  Lines(Vec<WithIndices<'a, Rope<'a>>>),
+enum SourceContent<'context, 'text> {
+  Raw(Rope<'text>),
+  Lines(Vec<WithIndices<'context, 'text, Rope<'text>>>),
 }
 
-fn check_content_at_position<'a>(
-  lines: &[WithIndices<'a, Rope<'a>>],
+fn check_content_at_position<'text>(
+  lines: &[WithIndices<'_, 'text, Rope<'text>>],
   line: u32,
   column: u32,
   expected: Rope, // FIXME: memory
@@ -391,7 +391,9 @@ impl StreamChunks for ReplaceSource {
           match source_content {
             SourceContent::Raw(source) => {
               let lines = split_into_lines(source)
-                .map(|line| WithIndices::new(options.work_context.clone(), line))
+                .map(|line| {
+                  WithIndices::new(options.work_context.as_ref(), line)
+                })
                 .collect::<Vec<_>>();
               let matched =
                 check_content_at_position(&lines, line, column, expected_chunk);
@@ -411,7 +413,7 @@ impl StreamChunks for ReplaceSource {
       &MapOptions {
         columns: options.columns,
         final_source: false,
-        work_context: options.work_context.clone()
+        work_context: options.work_context.clone(),
       },
       &mut |chunk, mut mapping| {
         // SAFETY: final_source is false in ReplaceSource

src/source.rs

@@ -1,12 +1,21 @@
 use std::{
-  any::{Any, TypeId}, borrow::Cow, collections::BinaryHeap, convert::{TryFrom, TryInto}, fmt, hash::{Hash, Hasher}, rc::Rc, sync::Arc
+  any::{Any, TypeId},
+  borrow::Cow,
+  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, work_context::WorkContext, Result
+  helpers::{decode_mappings, StreamChunks},
+  rope::Rope,
+  work_context::WorkContext,
+  Result,
 };
 
 /// An alias for `Box<dyn Source>`.
@@ -272,7 +281,7 @@ impl Default for MapOptions {
     Self {
       columns: true,
       final_source: false,
-      work_context: Default::default()
+      work_context: Default::default(),
     }
   }
 }

src/with_indices.rs

@@ -1,25 +1,28 @@
-use std::{cell::OnceCell, marker::PhantomData, rc::Rc};
+use std::{cell::OnceCell, marker::PhantomData};
 
-use crate::{helpers::SourceText, work_context::{PooledVec, WorkContext}};
+use crate::{
+  helpers::SourceText,
+  work_context::{PooledUsizeVec, WorkContext},
+};
 
 #[derive(Debug)]
-pub struct WithIndices<'a, S>
+pub struct WithIndices<'context, 'text, S>
 where
-  S: SourceText<'a>,
+  S: SourceText<'text>,
 {
   /// line is a string reference
   pub line: S,
   /// the byte position of each `char` in `line` string slice .
-  pub indices_indexes: OnceCell<PooledVec>,
-  work_context: Rc<WorkContext>,
-  data: PhantomData<&'a S>,
+  pub indices_indexes: OnceCell<PooledUsizeVec<'context>>,
+  work_context: &'context WorkContext,
+  data: PhantomData<&'text S>,
 }
 
-impl<'a, S> WithIndices<'a, S>
+impl<'context, 'text, S> WithIndices<'context, 'text, S>
 where
-  S: SourceText<'a>,
+  S: SourceText<'text>,
 {
-  pub fn new(work_context: Rc<WorkContext>, line: S) -> Self {
+  pub fn new(work_context: &'context WorkContext, line: S) -> Self {
     Self {
       indices_indexes: OnceCell::new(),
       line,
@@ -34,11 +37,9 @@ where
       return S::default();
     }
 
-    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);
-      }
+    let indices_indexes = self.indices_indexes.get_or_init(|| {
+      let mut vec = PooledUsizeVec::new(self.work_context, self.line.len());
+      vec.extend(self.line.char_indices().map(|(i, _)| i));
       vec
     });
 
@@ -59,42 +60,55 @@ where
 /// tests are just copy from `substring` crate
 #[cfg(test)]
 mod tests {
-  use std::rc::Rc;
-
-use crate::{work_context::WorkContext, Rope};
+  use crate::{work_context::WorkContext, Rope};
 
   use super::WithIndices;
   #[test]
   fn test_substring() {
     assert_eq!(
-      WithIndices::new(Rc::new(WorkContext::default()), Rope::from("foobar")).substring(0, 3),
+      WithIndices::new(&WorkContext::default(), Rope::from("foobar"))
+        .substring(0, 3),
       "foo"
     );
   }
 
   #[test]
   fn test_out_of_bounds() {
     assert_eq!(
-      WithIndices::new(Rc::new(WorkContext::default()), Rope::from("foobar")).substring(0, 10),
+      WithIndices::new(&WorkContext::default(), Rope::from("foobar"))
+        .substring(0, 10),
       "foobar"
     );
-    assert_eq!(WithIndices::new(Rc::new(WorkContext::default()), Rope::from("foobar")).substring(6, 10), "");
+    assert_eq!(
+      WithIndices::new(&WorkContext::default(), Rope::from("foobar"))
+        .substring(6, 10),
+      ""
+    );
   }
 
   #[test]
   fn test_start_less_than_end() {
-    assert_eq!(WithIndices::new(Rc::new(WorkContext::default()), Rope::from("foobar")).substring(3, 2), "");
+    assert_eq!(
+      WithIndices::new(&WorkContext::default(), Rope::from("foobar"))
+        .substring(3, 2),
+      ""
+    );
   }
 
   #[test]
   fn test_start_and_end_equal() {
-    assert_eq!(WithIndices::new(Rc::new(WorkContext::default()), Rope::from("foobar")).substring(3, 3), "");
+    assert_eq!(
+      WithIndices::new(&WorkContext::default(), Rope::from("foobar"))
+        .substring(3, 3),
+      ""
+    );
   }
 
   #[test]
   fn test_multiple_byte_characters() {
     assert_eq!(
-      WithIndices::new(Rc::new(WorkContext::default()), Rope::from("fõøbα®")).substring(2, 5),
+      WithIndices::new(&WorkContext::default(), Rope::from("fõøbα®"))
+        .substring(2, 5),
       "øbα"
     );
   }

src/work_context.rs

@@ -1,5 +1,12 @@
-use std::{cell::RefCell, collections::BTreeMap, rc::Rc};
+use std::{cell::RefCell, collections::BTreeMap};
 
+// Vector pooling minimum capacity threshold
+// Recommended threshold: 64
+// Reasons:
+// 1. Memory consideration: 64 * 8 bytes = 512 bytes, a reasonable memory block size
+// 2. Allocation cost: Allocations smaller than 512 bytes are usually fast, pooling benefits are limited
+// 3. Cache friendly: 512 bytes can typically utilize CPU cache well
+// 4. Empirical value: 64 is a proven balance point in real projects
 const MIN_POOL_CAPACITY: usize = 64;
 
 #[derive(Default, Debug)]
@@ -8,18 +15,16 @@ pub struct WorkContext {
 }
 
 impl WorkContext {
-  pub fn new() -> Self {
-    Self {
-      usize_vec_pool: RefCell::new(BTreeMap::new()),
-    }
-  }
-
   pub fn pull_usize_vec(&self, requested_capacity: usize) -> Vec<usize> {
-    if requested_capacity < MIN_POOL_CAPACITY {
+    if requested_capacity < MIN_POOL_CAPACITY
+      || self.usize_vec_pool.borrow().len() == 0
+    {
       return Vec::with_capacity(requested_capacity);
     }
     let mut usize_vec_pool = self.usize_vec_pool.borrow_mut();
-    if let Some((_, bucket)) = usize_vec_pool.range_mut(requested_capacity..).next() {
+    if let Some((_, bucket)) =
+      usize_vec_pool.range_mut(requested_capacity..).next()
+    {
       if let Some(mut v) = bucket.pop() {
         v.clear();
         return v;
@@ -40,13 +45,13 @@ impl WorkContext {
 }
 
 #[derive(Debug)]
-pub struct PooledVec {
+pub struct PooledUsizeVec<'a> {
   vec: Option<Vec<usize>>,
-  context: Rc<WorkContext>,
+  context: &'a WorkContext,
 }
 
-impl PooledVec {
-  pub fn new(context: Rc<WorkContext>, requested_capacity: usize) -> Self {
+impl<'a> PooledUsizeVec<'a> {
+  pub fn new(context: &'a WorkContext, requested_capacity: usize) -> Self {
     let vec = context.pull_usize_vec(requested_capacity);
     Self {
       vec: Some(vec),
@@ -63,23 +68,23 @@ impl PooledVec {
   }
 }
 
-impl Drop for PooledVec {
+impl Drop for PooledUsizeVec<'_> {
   fn drop(&mut self) {
     if let Some(vec) = self.vec.take() {
       self.context.return_usize_vec(vec);
     }
   }
 }
 
-impl std::ops::Deref for PooledVec {
+impl std::ops::Deref for PooledUsizeVec<'_> {
   type Target = Vec<usize>;
 
   fn deref(&self) -> &Self::Target {
     self.as_ref()
   }
 }
 
-impl std::ops::DerefMut for PooledVec {
+impl std::ops::DerefMut for PooledUsizeVec<'_> {
   fn deref_mut(&mut self) -> &mut Self::Target {
     self.as_mut()
   }