revert: stream_chunks_of_source_map_full

.github/workflows/Bench.yaml

@@ -19,7 +19,7 @@ concurrency:
 
 jobs:
   benchmark:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     steps:
       - uses: actions/checkout@v4
 

src/helpers.rs

@@ -16,7 +16,7 @@ use crate::{
 
 // Adding this type because sourceContentLine not happy
 type InnerSourceContentLine<'a> =
-  RefCell<LinearMap<OnceCell<Option<Vec<WithIndices<&'a str>>>>>>;
+  RefCell<LinearMap<OnceCell<Option<Vec<WithIndices<'a>>>>>>;
 
 pub fn get_map<'a, S: StreamChunks<'a>>(
   stream: &'a S,
@@ -376,95 +376,144 @@ fn stream_chunks_of_source_map_full<'a>(
   on_source: OnSource<'_, 'a>,
   on_name: OnName<'_, 'a>,
 ) -> GeneratedInfo {
+  let lines = split_into_lines(source);
+  let line_with_indices_list = lines.map(WithIndices::new).collect::<Vec<_>>();
+
+  if line_with_indices_list.is_empty() {
+    return GeneratedInfo {
+      generated_line: 1,
+      generated_column: 0,
+    };
+  }
   for (i, source) in source_map.sources().iter().enumerate() {
     on_source(
       i as u32,
       get_source(source_map, source),
       source_map.get_source_content(i),
     )
   }
-
   for (i, name) in source_map.names().iter().enumerate() {
     on_name(i as u32, Cow::Borrowed(name));
   }
-
+  let last_line = line_with_indices_list[line_with_indices_list.len() - 1].line;
+  let last_new_line = last_line.ends_with('\n');
+  let final_line: u32 = if last_new_line {
+    line_with_indices_list.len() + 1
+  } else {
+    line_with_indices_list.len()
+  } as u32;
+  let final_column: u32 =
+    if last_new_line { 0 } else { last_line.len() } as u32;
   let mut current_generated_line: u32 = 1;
   let mut current_generated_column: u32 = 0;
+  let mut mapping_active = false;
+  let mut active_mapping_original: Option<OriginalLocation> = None;
 
-  let mut tracking_generated_index: usize = 0;
-  let mut tracking_generated_line: u32 = 1;
-  let mut tracking_generated_column: u32 = 0;
-  let mut tracking_mapping_original: Option<OriginalLocation> = None;
-
-  let mut mappings_iter = source_map.decoded_mappings();
-  let mut current_mapping = mappings_iter.next();
-
-  for (current_generated_index, c) in source.char_indices() {
-    if let Some(mapping) = &current_mapping {
-      if mapping.generated_line == current_generated_line
-        && mapping.generated_column == current_generated_column
-      {
-        let chunk = &source[tracking_generated_index..current_generated_index];
-        if !chunk.is_empty() {
-          on_chunk(
-            Some(Cow::Borrowed(chunk)),
-            Mapping {
-              generated_line: tracking_generated_line,
-              generated_column: tracking_generated_column,
-              original: tracking_mapping_original,
-            },
-          );
-        }
-
-        tracking_generated_index = current_generated_index;
-        tracking_generated_line = mapping.generated_line;
-        tracking_generated_column = mapping.generated_column;
-        tracking_mapping_original = mapping.original.clone();
-
-        current_mapping = mappings_iter.next();
+  let mut on_mapping = |mapping: Mapping| {
+    if mapping_active
+      && current_generated_line as usize <= line_with_indices_list.len()
+    {
+      let chunk: &str;
+      let mapping_line = current_generated_line;
+      let mapping_column = current_generated_column;
+      let line = &line_with_indices_list[(current_generated_line - 1) as usize];
+      if mapping.generated_line != current_generated_line {
+        chunk = line.substring(current_generated_column as usize, usize::MAX);
+        current_generated_line += 1;
+        current_generated_column = 0;
+      } else {
+        chunk = line.substring(
+          current_generated_column as usize,
+          mapping.generated_column as usize,
+        );
+        current_generated_column = mapping.generated_column;
       }
-    }
-
-    current_generated_column += 1;
-    if c == '\n' {
-      if tracking_generated_line == current_generated_line {
-        let chunk =
-          &source[tracking_generated_index..current_generated_index + 1];
+      if !chunk.is_empty() {
         on_chunk(
           Some(Cow::Borrowed(chunk)),
           Mapping {
-            generated_line: tracking_generated_line,
-            generated_column: tracking_generated_column,
-            original: tracking_mapping_original,
+            generated_line: mapping_line,
+            generated_column: mapping_column,
+            original: active_mapping_original.clone(),
+          },
+        )
+      }
+      mapping_active = false;
+    }
+    if mapping.generated_line > current_generated_line
+      && current_generated_column > 0
+    {
+      if current_generated_line as usize <= line_with_indices_list.len() {
+        let chunk = &line_with_indices_list
+          [(current_generated_line - 1) as usize]
+          .substring(current_generated_column as usize, usize::MAX);
+        on_chunk(
+          Some(Cow::Owned(chunk.to_string())),
+          Mapping {
+            generated_line: current_generated_line,
+            generated_column: current_generated_column,
+            original: None,
           },
         );
-
-        tracking_generated_index = current_generated_index + 1;
-        tracking_generated_line += 1;
-        tracking_generated_column = 0;
-        tracking_mapping_original = None;
       }
-
       current_generated_line += 1;
       current_generated_column = 0;
     }
-  }
+    while mapping.generated_line > current_generated_line {
+      if current_generated_line as usize <= line_with_indices_list.len() {
+        let chunk =
+          line_with_indices_list[(current_generated_line as usize) - 1].line;
+        on_chunk(
+          Some(Cow::Owned(chunk.to_string())),
+          Mapping {
+            generated_line: current_generated_line,
+            generated_column: 0,
+            original: None,
+          },
+        );
+      }
+      current_generated_line += 1;
+    }
+    if mapping.generated_column > current_generated_column {
+      if current_generated_line as usize <= line_with_indices_list.len() {
+        let chunk = line_with_indices_list
+          [(current_generated_line as usize) - 1]
+          .substring(
+            current_generated_column as usize,
+            mapping.generated_column as usize,
+          );
+        on_chunk(
+          Some(Cow::Owned(chunk.to_string())),
+          Mapping {
+            generated_line: current_generated_line,
+            generated_column: current_generated_column,
+            original: None,
+          },
+        )
+      }
+      current_generated_column = mapping.generated_column;
+    }
+    if let Some(original) = mapping.original.filter(|_| {
+      mapping.generated_line < final_line
+        || (mapping.generated_line == final_line
+          && mapping.generated_column < final_column)
+    }) {
+      mapping_active = true;
+      active_mapping_original = Some(original);
+    }
+  };
 
-  if tracking_generated_index < source.len() {
-    let chunk = &source[tracking_generated_index..];
-    on_chunk(
-      Some(Cow::Borrowed(chunk)),
-      Mapping {
-        generated_line: tracking_generated_line,
-        generated_column: tracking_generated_column,
-        original: tracking_mapping_original,
-      },
-    );
+  for mapping in source_map.decoded_mappings() {
+    on_mapping(mapping);
   }
-
+  on_mapping(Mapping {
+    generated_line: final_line,
+    generated_column: final_column,
+    original: None,
+  });
   GeneratedInfo {
-    generated_line: current_generated_line,
-    generated_column: current_generated_column,
+    generated_line: final_line,
+    generated_column: final_column,
   }
 }
 

src/with_indices.rs

@@ -1,15 +1,15 @@
 use std::cell::OnceCell;
 
 #[derive(Debug, Clone)]
-pub struct WithIndices<T: AsRef<str>> {
+pub struct WithIndices<'a> {
   /// line is a string reference
-  pub line: T,
+  pub line: &'a str,
   /// the byte position of each `char` in `line` string slice .
   pub indices_indexes: OnceCell<Vec<usize>>,
 }
 
-impl<T: AsRef<str>> WithIndices<T> {
-  pub fn new(line: T) -> Self {
+impl<'a> WithIndices<'a> {
+  pub fn new(line: &'a str) -> Self {
     Self {
       indices_indexes: OnceCell::new(),
       line,
@@ -18,24 +18,27 @@ impl<T: AsRef<str>> WithIndices<T> {
 
   /// substring::SubString with cache
   #[allow(unsafe_code)]
-  pub(crate) fn substring(&self, start_index: usize, end_index: usize) -> &str {
+  pub(crate) fn substring(
+    &self,
+    start_index: usize,
+    end_index: usize,
+  ) -> &'a str {
     if end_index <= start_index {
       return "";
     }
 
-    let line = self.line.as_ref();
-    let indices_indexes = self
-      .indices_indexes
-      .get_or_init(|| line.char_indices().map(|(i, _)| i).collect::<Vec<_>>());
+    let indices_indexes = self.indices_indexes.get_or_init(|| {
+      self.line.char_indices().map(|(i, _)| i).collect::<Vec<_>>()
+    });
 
-    let str_len = line.len();
+    let str_len = self.line.len();
     let start = *indices_indexes.get(start_index).unwrap_or(&str_len);
     let end = *indices_indexes.get(end_index).unwrap_or(&str_len);
     unsafe {
       // SAFETY: Since `indices` iterates over the `CharIndices` of `self`, we can guarantee
       // that the indices obtained from it will always be within the bounds of `self` and they
       // will always lie on UTF-8 sequence boundaries.
-      line.get_unchecked(start..end)
+      self.line.get_unchecked(start..end)
     }
   }
 }