chore: merge origin main

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::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,
@@ -747,7 +749,7 @@ struct SourceMapLineData<'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>(
@@ -767,27 +769,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() {
@@ -835,6 +838,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;
@@ -848,6 +853,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];
@@ -924,6 +930,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();
@@ -951,6 +958,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
@@ -1065,11 +1073,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(
@@ -1083,9 +1096,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();
@@ -1115,9 +1133,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);
@@ -1181,7 +1198,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));
@@ -1192,7 +1208,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);
           },
@@ -1216,7 +1231,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,
 };
 
@@ -258,8 +259,8 @@ 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<HashMap<u32, u32>> =
@@ -294,7 +295,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
@@ -585,11 +586,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| {