perf: linear mapping (#111)

Author: SyMind

src/concat_source.rs

@@ -8,6 +8,7 @@ use rustc_hash::FxHashMap as HashMap;
 
 use crate::{
   helpers::{get_map, GeneratedInfo, OnChunk, OnName, OnSource, StreamChunks},
+  linear_map::LinearMap,
   source::{Mapping, OriginalLocation},
   BoxSource, MapOptions, Source, SourceExt, SourceMap,
 };
@@ -163,10 +164,10 @@ impl<'a> StreamChunks<'a> for ConcatSource {
     let mut name_mapping: HashMap<Cow<str>, u32> = HashMap::default();
     let mut need_to_close_mapping = false;
 
-    let source_index_mapping: RefCell<HashMap<u32, u32>> =
-      RefCell::new(HashMap::default());
-    let name_index_mapping: RefCell<HashMap<u32, u32>> =
-      RefCell::new(HashMap::default());
+    let source_index_mapping: RefCell<LinearMap<u32>> =
+      RefCell::new(LinearMap::default());
+    let name_index_mapping: RefCell<LinearMap<u32>> =
+      RefCell::new(LinearMap::default());
 
     for item in self.children() {
       source_index_mapping.borrow_mut().clear();

src/helpers.rs

@@ -1,13 +1,15 @@
 use arrayvec::ArrayVec;
-use rustc_hash::FxHashMap as HashMap;
 use std::{
   borrow::{BorrowMut, Cow},
   cell::{OnceCell, RefCell},
   rc::Rc,
 };
 
+use rustc_hash::FxHashMap as HashMap;
+
 use crate::{
   encoder::create_encoder,
+  linear_map::LinearMap,
   source::{Mapping, OriginalLocation},
   vlq::decode,
   with_indices::WithIndices,
@@ -16,7 +18,7 @@ use crate::{
 
 // Adding this type because sourceContentLine not happy
 type InnerSourceContentLine<'a> =
-  RefCell<HashMap<i64, Option<Rc<Vec<WithIndices<&'a str>>>>>>;
+  RefCell<HashMap<u32, Option<Rc<Vec<WithIndices<&'a str>>>>>>;
 
 pub fn get_map<'a, S: StreamChunks<'a>>(
   stream: &'a S,
@@ -776,7 +778,7 @@ impl<'a> SourceMapLineChunk<'a> {
 }
 
 type InnerSourceIndexValueMapping<'a> =
-  HashMap<i64, (Cow<'a, str>, Option<&'a str>)>;
+  LinearMap<(Cow<'a, str>, Option<&'a str>)>;
 
 #[allow(clippy::too_many_arguments)]
 pub fn stream_chunks_of_combined_source_map<'a>(
@@ -796,27 +798,28 @@ pub fn stream_chunks_of_combined_source_map<'a>(
   let source_mapping: RefCell<HashMap<Cow<str>, u32>> =
     RefCell::new(HashMap::default());
   let mut name_mapping: HashMap<Cow<str>, u32> = HashMap::default();
-  let source_index_mapping: RefCell<HashMap<i64, i64>> =
-    RefCell::new(HashMap::default());
-  let name_index_mapping: RefCell<HashMap<i64, i64>> =
-    RefCell::new(HashMap::default());
-  let name_index_value_mapping: RefCell<HashMap<i64, Cow<str>>> =
-    RefCell::new(HashMap::default());
+  let source_index_mapping: RefCell<LinearMap<i64>> =
+    RefCell::new(LinearMap::default());
+  let name_index_mapping: RefCell<LinearMap<i64>> =
+    RefCell::new(LinearMap::default());
+  let name_index_value_mapping: RefCell<LinearMap<Cow<str>>> =
+    RefCell::new(LinearMap::default());
   let inner_source_index: RefCell<i64> = RefCell::new(-2);
-  let inner_source_index_mapping: RefCell<HashMap<i64, i64>> =
-    RefCell::new(HashMap::default());
+  let inner_source_index_mapping: RefCell<LinearMap<i64>> =
+    RefCell::new(LinearMap::default());
   let inner_source_index_value_mapping: RefCell<InnerSourceIndexValueMapping> =
-    RefCell::new(HashMap::default());
-  let inner_source_contents: RefCell<HashMap<i64, Option<&str>>> =
-    RefCell::new(HashMap::default());
+    RefCell::new(LinearMap::default());
+  let inner_source_contents: RefCell<LinearMap<Option<&str>>> =
+    RefCell::new(LinearMap::default());
   let inner_source_content_lines: InnerSourceContentLine =
     RefCell::new(HashMap::default());
-  let inner_name_index_mapping: RefCell<HashMap<i64, i64>> =
-    RefCell::new(HashMap::default());
-  let inner_name_index_value_mapping: RefCell<HashMap<i64, Cow<str>>> =
-    RefCell::new(HashMap::default());
+  let inner_name_index_mapping: RefCell<LinearMap<i64>> =
+    RefCell::new(LinearMap::default());
+  let inner_name_index_value_mapping: RefCell<LinearMap<Cow<str>>> =
+    RefCell::new(LinearMap::default());
   let inner_source_map_line_data: RefCell<Vec<SourceMapLineData>> =
     RefCell::new(Vec::new());
+
   let find_inner_mapping = |line: i64, column: i64| -> Option<u32> {
     let inner_source_map_line_data = inner_source_map_line_data.borrow();
     if line as usize > inner_source_map_line_data.len() {
@@ -864,6 +867,8 @@ pub fn stream_chunks_of_combined_source_map<'a>(
 
       // Check if this is a mapping to the inner source
       if source_index == *inner_source_index.borrow() {
+        let source_index = source_index as u32;
+
         // Check if there is a mapping in the inner source
         if let Some(idx) = find_inner_mapping(original_line, original_column) {
           let idx = idx as usize;
@@ -877,6 +882,7 @@ pub fn stream_chunks_of_combined_source_map<'a>(
           let mut inner_original_column = mappings_data[mi + 3];
           let mut inner_name_index = mappings_data[mi + 4];
           if inner_source_index >= 0 {
+            let inner_source_index = inner_source_index as u32;
             // Check for an identity mapping
             // where we are allowed to adjust the original column
             let inner_chunk = &chunks[idx];
@@ -953,6 +959,7 @@ pub fn stream_chunks_of_combined_source_map<'a>(
             // emit name when needed and compute global name index
             let mut final_name_index = -1;
             if inner_name_index >= 0 {
+              let inner_name_index = inner_name_index as u32;
               // when we have a inner name
               let mut inner_name_index_mapping =
                 inner_name_index_mapping.borrow_mut();
@@ -980,6 +987,7 @@ pub fn stream_chunks_of_combined_source_map<'a>(
                   .insert(inner_name_index, final_name_index);
               }
             } else if name_index >= 0 {
+              let name_index = name_index as u32;
               // when we don't have an inner name,
               // but we have an outer name
               // it can be used when inner original code equals to the name
@@ -1094,11 +1102,16 @@ pub fn stream_chunks_of_combined_source_map<'a>(
         }
       }
 
-      let final_source_index = source_index_mapping
-        .borrow()
-        .get(&source_index)
-        .copied()
-        .unwrap_or(-1);
+      let final_source_index = if source_index < 0 {
+        -1
+      } else {
+        let source_index = source_index as u32;
+        source_index_mapping
+          .borrow()
+          .get(&source_index)
+          .copied()
+          .unwrap_or(-1)
+      };
       if final_source_index < 0 {
         // no source, so we make it a generated chunk
         on_chunk(
@@ -1112,9 +1125,14 @@ pub fn stream_chunks_of_combined_source_map<'a>(
       } else {
         // Pass through the chunk with mapping
         let mut name_index_mapping = name_index_mapping.borrow_mut();
-        let mut final_name_index =
-          name_index_mapping.get(&name_index).copied().unwrap_or(-1);
+        let mut final_name_index = if name_index >= 0 {
+          let name_index = name_index as u32;
+          name_index_mapping.get(&name_index).copied().unwrap_or(-1)
+        } else {
+          -1
+        };
         if final_name_index == -2 {
+          let name_index = name_index as u32;
           let name_index_value_mapping = name_index_value_mapping.borrow();
           let name = name_index_value_mapping.get(&name_index).unwrap();
           let mut global_index = name_mapping.get(name).copied();
@@ -1144,9 +1162,8 @@ pub fn stream_chunks_of_combined_source_map<'a>(
       }
     },
     &mut |i, source, mut source_content| {
-      let i = i as i64;
       if source == inner_source_name {
-        *inner_source_index.borrow_mut() = i;
+        *inner_source_index.borrow_mut() = i as i64;
         let mut inner_source = inner_source.borrow_mut();
         if let Some(inner_source) = inner_source.as_ref() {
           source_content = Some(inner_source);
@@ -1210,7 +1227,6 @@ pub fn stream_chunks_of_combined_source_map<'a>(
             data.chunks.push(chunk);
           },
           &mut |i, source, source_content| {
-            let i = i as i64;
             inner_source_contents
               .borrow_mut()
               .insert(i, source_content.map(Into::into));
@@ -1221,7 +1237,6 @@ pub fn stream_chunks_of_combined_source_map<'a>(
               .insert(i, (source, source_content));
           },
           &mut |i, name| {
-            let i = i as i64;
             inner_name_index_mapping.borrow_mut().insert(i, -2);
             inner_name_index_value_mapping.borrow_mut().insert(i, name);
           },
@@ -1245,7 +1260,6 @@ pub fn stream_chunks_of_combined_source_map<'a>(
       }
     },
     &mut |i, name| {
-      let i = i as i64;
       name_index_mapping.borrow_mut().insert(i, -2);
       name_index_value_mapping.borrow_mut().insert(i, name);
     },

src/lib.rs

@@ -5,6 +5,7 @@ mod concat_source;
 mod encoder;
 mod error;
 mod helpers;
+mod linear_map;
 mod original_source;
 mod raw_source;
 mod replace_source;

src/linear_map.rs

@@ -0,0 +1,33 @@
+pub struct LinearMap<V: Default> {
+  inner: Vec<V>,
+}
+
+impl<V: Default> LinearMap<V> {
+  pub fn new() -> Self {
+    Self {
+      inner: Default::default(),
+    }
+  }
+
+  pub fn get(&self, key: &u32) -> Option<&V> {
+    self.inner.get(*key as usize)
+  }
+
+  pub fn insert(&mut self, key: u32, value: V) {
+    let key = key as usize;
+    if key >= self.inner.len() {
+      self.inner.resize_with(key + 1, Default::default);
+    }
+    self.inner[key] = value;
+  }
+
+  pub fn clear(&mut self) {
+    self.inner.clear()
+  }
+}
+
+impl<V: Default> Default for LinearMap<V> {
+  fn default() -> Self {
+    Self::new()
+  }
+}

src/replace_source.rs

@@ -12,6 +12,7 @@ use rustc_hash::FxHashMap as HashMap;
 
 use crate::{
   helpers::{get_map, split_into_lines, GeneratedInfo, StreamChunks},
+  linear_map::LinearMap,
   MapOptions, Mapping, OriginalLocation, Source, SourceMap,
 };
 
@@ -273,11 +274,12 @@ impl<'a, T: Source> StreamChunks<'a> for ReplaceSource<T> {
     let mut generated_line_offset: i64 = 0;
     let mut generated_column_offset: i64 = 0;
     let mut generated_column_offset_line = 0;
-    let source_content_lines: RefCell<Vec<Option<Vec<&str>>>> =
-      RefCell::new(Vec::new());
+    let source_content_lines: RefCell<LinearMap<Option<Vec<&str>>>> =
+      RefCell::new(LinearMap::default());
     let name_mapping: RefCell<HashMap<Cow<str>, u32>> =
       RefCell::new(HashMap::default());
-    let name_index_mapping: RefCell<Vec<u32>> = RefCell::new(Vec::new());
+    let name_index_mapping: RefCell<LinearMap<u32>> =
+      RefCell::new(LinearMap::default());
 
     // check if source_content[line][col] is equal to expect
     // Why this is needed?
@@ -308,7 +310,7 @@ impl<'a, T: Source> StreamChunks<'a> for ReplaceSource<T> {
     let check_original_content =
       |source_index: u32, line: u32, column: u32, expected_chunk: &str| {
         if let Some(Some(content_lines)) =
-          source_content_lines.borrow().get(source_index as usize)
+          source_content_lines.borrow().get(&source_index)
         {
           if let Some(content_line) = content_lines.get(line as usize - 1) {
             match content_line
@@ -411,10 +413,7 @@ impl<'a, T: Source> StreamChunks<'a> for ReplaceSource<T> {
                     original_line: original.original_line,
                     original_column: original.original_column,
                     name_index: original.name_index.and_then(|name_index| {
-                      name_index_mapping
-                        .borrow()
-                        .get(name_index as usize)
-                        .copied()
+                      name_index_mapping.borrow().get(&name_index).copied()
                     }),
                   }
                 }),
@@ -589,10 +588,7 @@ impl<'a, T: Source> StreamChunks<'a> for ReplaceSource<T> {
                   original_line: original.original_line,
                   original_column: original.original_column,
                   name_index: original.name_index.and_then(|name_index| {
-                    name_index_mapping
-                      .borrow()
-                      .get(name_index as usize)
-                      .copied()
+                    name_index_mapping.borrow().get(&name_index).copied()
                   }),
                 }
               }),
@@ -603,11 +599,9 @@ impl<'a, T: Source> StreamChunks<'a> for ReplaceSource<T> {
       },
       &mut |source_index, source, source_content| {
         let mut source_content_lines = source_content_lines.borrow_mut();
-        while source_content_lines.len() <= source_index as usize {
-          source_content_lines.push(None);
-        }
-        source_content_lines[source_index as usize] = source_content
+        let lines = source_content
           .map(|source_content| split_into_lines(source_content).collect());
+        source_content_lines.insert(source_index, lines);
         on_source(source_index, source, source_content);
       },
       &mut |name_index, name| {
@@ -621,7 +615,7 @@ impl<'a, T: Source> StreamChunks<'a> for ReplaceSource<T> {
         }
         name_index_mapping
           .borrow_mut()
-          .insert(name_index as usize, global_index.unwrap());
+          .insert(name_index, global_index.unwrap());
       },
     );