refactor: SourceMap

Author: SyMind

Cargo.lock

@@ -42,6 +42,7 @@ itertools = "0.13"
 codspeed-criterion-compat = { version = "2.7.2", default-features = false, optional = true }
 static_assertions = "1.1.0"
 simd-json = "0.14.3"
+self_cell = "1.2.0"
 
 [dev-dependencies]
 twox-hash = "2.1.0"

Cargo.toml

@@ -13,7 +13,7 @@ use crate::{
     stream_chunks_of_source_map, StreamChunks,
   },
   rope::Rope,
-  MapOptions, Source, SourceMap,
+  BoxSource, MapOptions, Source, SourceExt, SourceMap,
 };
 
 /// It tries to reused cached results from other methods to avoid calculations,
@@ -49,36 +49,60 @@ use crate::{
 ///   "Hello World\nconsole.log('test');\nconsole.log('test2');\nHello2\n"
 /// );
 /// ```
-pub struct CachedSource<T> {
-  inner: Arc<T>,
-  cached_hash: Arc<OnceLock<u64>>,
-  cached_maps:
-    Arc<DashMap<MapOptions, Option<SourceMap>, BuildHasherDefault<FxHasher>>>,
+
+#[derive(Debug)]
+struct CachedSourceOwner {
+  inner: BoxSource,
+  cached_hash: OnceLock<u64>,
+}
+
+#[derive(Debug)]
+struct CachedSourceDependent<'a> {
+  cached_colomns_map: OnceLock<Option<SourceMap<'static>>>,
+  cached_line_only_map: OnceLock<Option<SourceMap<'static>>>,
+  phantom: std::marker::PhantomData<&'a ()>,
 }
 
-impl<T> CachedSource<T> {
+self_cell::self_cell!(
+  struct CachedSourceCell {
+    owner: CachedSourceOwner,
+
+    #[covariant]
+    dependent: CachedSourceDependent,
+  }
+
+  impl { Debug }
+);
+
+pub struct CachedSource(CachedSourceCell);
+
+impl CachedSource {
   /// Create a [CachedSource] with the original [Source].
-  pub fn new(inner: T) -> Self {
-    Self {
-      inner: Arc::new(inner),
-      cached_hash: Default::default(),
-      cached_maps: Default::default(),
-    }
+  pub fn new<T: SourceExt>(inner: T) -> Self {
+    let owner = CachedSourceOwner {
+      inner: inner.boxed(),
+      cached_hash: OnceLock::new(),
+    };
+    Self(CachedSourceCell::new(owner, |_| CachedSourceDependent {
+      cached_colomns_map: Default::default(),
+      cached_line_only_map: Default::default(),
+      phantom: std::marker::PhantomData,
+    }))
   }
 
   /// Get the original [Source].
-  pub fn original(&self) -> &T {
-    &self.inner
+  pub fn original(&self) -> &BoxSource {
+    &self.0.borrow_owner().inner
   }
 }
 
-impl<T: Source + Hash + PartialEq + Eq + 'static> Source for CachedSource<T> {
+impl Source for CachedSource {
   fn source(&self) -> Cow<str> {
-    self.inner.source()
+    self.0.borrow_owner().inner.source()
   }
 
   fn rope(&self) -> Rope<'_> {
-    self.inner.rope()
+    self.0.borrow_owner().inner.rope()
   }
 
   fn buffer(&self) -> Cow<[u8]> {
@@ -88,101 +112,114 @@ impl<T: Source + Hash + PartialEq + Eq + 'static> Source for CachedSource<T> {
   }
 
   fn size(&self) -> usize {
-    self.inner.size()
+    self.0.borrow_owner().inner.size()
   }
 
   fn map(&self, options: &MapOptions) -> Option<SourceMap> {
-    if let Some(map) = self.cached_maps.get(options) {
-      map.clone()
+    if options.columns {
+      self.0.with_dependent(|owner, dependent| {
+        dependent.cached_colomns_map.get_or_init(|| {
+          let map = owner.inner.map(options);
+          unsafe { std::mem::transmute::<Option<SourceMap>, Option<SourceMap<'static>>>(map) }
+        }).clone()
+      })
     } else {
-      let map = self.inner.map(options);
-      self.cached_maps.insert(options.clone(), map.clone());
-      map
+      self.0.with_dependent(|owner, dependent| {
+        dependent.cached_line_only_map.get_or_init(|| {
+          let map = owner.inner.map(options);
+          unsafe { std::mem::transmute::<Option<SourceMap>, Option<SourceMap<'static>>>(map) }
+        }).clone()
+      })
     }
   }
 
   fn to_writer(&self, writer: &mut dyn std::io::Write) -> std::io::Result<()> {
-    self.inner.to_writer(writer)
+    self.0.borrow_owner().inner.to_writer(writer)
   }
 }
 
-impl<T: Source + Hash + PartialEq + Eq + 'static> StreamChunks
-  for CachedSource<T>
-{
+impl StreamChunks for CachedSource {
   fn stream_chunks<'a>(
     &'a self,
     options: &MapOptions,
     on_chunk: crate::helpers::OnChunk<'_, 'a>,
     on_source: crate::helpers::OnSource<'_, 'a>,
     on_name: crate::helpers::OnName<'_, 'a>,
   ) -> crate::helpers::GeneratedInfo {
-    let cached_map = self.cached_maps.entry(options.clone());
-    match cached_map {
-      Entry::Occupied(entry) => {
-        let source = self.rope();
-        if let Some(map) = entry.get() {
-          #[allow(unsafe_code)]
-          // SAFETY: We guarantee that once a `SourceMap` is stored in the cache, it will never be removed.
-          // Therefore, even if we force its lifetime to be longer, the reference remains valid.
-          // This is based on the following assumptions:
-          // 1. `SourceMap` will be valid for the entire duration of the application.
-          // 2. The cached `SourceMap` will not be manually removed or replaced, ensuring the reference's safety.
-          let map =
-            unsafe { std::mem::transmute::<&SourceMap, &'a SourceMap>(map) };
-          stream_chunks_of_source_map(
-            source, map, on_chunk, on_source, on_name, options,
-          )
-        } else {
-          stream_chunks_of_raw_source(
-            source, options, on_chunk, on_source, on_name,
-          )
-        }
+    let cached = if options.columns {
+      self.0.borrow_dependent().cached_colomns_map.get()
+    } else {
+      self.0.borrow_dependent().cached_line_only_map.get()
+    };
+    match cached {
+      Some(Some(map)) => {
+        let source = self.0.borrow_owner().inner.rope();
+        stream_chunks_of_source_map(
+          source, map, on_chunk, on_source, on_name, options,
+        )
       }
-      Entry::Vacant(entry) => {
-        let (generated_info, map) = stream_and_get_source_and_map(
-          &self.inner as &T,
+      Some(None) => {
+        let source = self.0.borrow_owner().inner.rope();
+        stream_chunks_of_raw_source(
+          source, options, on_chunk, on_source, on_name,
+        )
+      }
+      None => {
+        if options.columns {
+          self.0.with_dependent(|owner, dependent| {
+            let (generated_info, map) = stream_and_get_source_and_map(
+          &owner.inner,
           options,
           on_chunk,
           on_source,
           on_name,
         );
-        entry.insert(map);
+            dependent.cached_colomns_map.get_or_init(|| {
+              unsafe { std::mem::transmute::<Option<SourceMap>, Option<SourceMap<'static>>>(map) }
+            });
         generated_info
+          })
+        } else {
+          self.0.with_dependent(|owner, dependent| {
+            let (generated_info, map) = stream_and_get_source_and_map(
+          &owner.inner,
+          options,
+          on_chunk,
+          on_source,
+          on_name,
+        );
+        dependent.cached_line_only_map.get_or_init(|| {
+              unsafe { std::mem::transmute::<Option<SourceMap>, Option<SourceMap<'static>>>(map) }
+            });
+        generated_info
+          })
+        }
       }
     }
   }
 }
 
-impl<T> Clone for CachedSource<T> {
-  fn clone(&self) -> Self {
-    Self {
-      inner: self.inner.clone(),
-      cached_hash: self.cached_hash.clone(),
-      cached_maps: self.cached_maps.clone(),
-    }
-  }
-}
-
-impl<T: Source + Hash + PartialEq + Eq + 'static> Hash for CachedSource<T> {
+impl Hash for CachedSource {
   fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-    (self.cached_hash.get_or_init(|| {
+    let owner = self.0.borrow_owner();
+    (owner.cached_hash.get_or_init(|| {
       let mut hasher = FxHasher::default();
-      self.inner.hash(&mut hasher);
+      owner.inner.hash(&mut hasher);
       hasher.finish()
     }))
     .hash(state);
   }
 }
 
-impl<T: PartialEq> PartialEq for CachedSource<T> {
+impl PartialEq for CachedSource {
   fn eq(&self, other: &Self) -> bool {
-    self.inner == other.inner
+    &self.0.borrow_owner().inner == &other.0.borrow_owner().inner
   }
 }
 
-impl<T: Eq> Eq for CachedSource<T> {}
+impl Eq for CachedSource {}
 
-impl<T: std::fmt::Debug> std::fmt::Debug for CachedSource<T> {
+impl std::fmt::Debug for CachedSource {
   fn fmt(
     &self,
     f: &mut std::fmt::Formatter<'_>,
@@ -194,7 +231,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for CachedSource<T> {
     writeln!(
       f,
       "{indent_str}{:indent$?}",
-      self.inner,
+      self.0.borrow_owner().inner,
       indent = indent + 2
     )?;
     write!(f, "{indent_str}).boxed()")
@@ -218,7 +255,7 @@ mod tests {
         value: "\nconsole.log(1);\n".to_string(),
         name: "index.js".to_string(),
         source_map: SourceMap::new(
-          ";AACA",
+          ";AACA".into(),
           vec!["index.js".into()],
           vec!["// DELETE IT\nconsole.log(1)".into()],
           vec![],
@@ -230,25 +267,6 @@ mod tests {
     assert_eq!(map.mappings(), ";;AACA");
   }
 
-  #[test]
-  fn should_allow_to_store_and_share_cached_data() {
-    let original = OriginalSource::new("Hello World", "test.txt");
-    let source = CachedSource::new(original);
-    let clone = source.clone();
-
-    // fill up cache
-    let map_options = MapOptions::default();
-    source.source();
-    source.buffer();
-    source.size();
-    source.map(&map_options);
-
-    assert_eq!(
-      *clone.cached_maps.get(&map_options).unwrap().value(),
-      source.map(&map_options)
-    );
-  }
-
   #[test]
   fn should_return_the_correct_size_for_binary_files() {
     let source = OriginalSource::new(