perf: next_segment

Author: SyMind

src/helpers.rs

@@ -1,4 +1,5 @@
 use arrayvec::ArrayVec;
+use core::fmt;
 use std::{
   borrow::{BorrowMut, Cow},
   cell::RefCell,
@@ -13,7 +14,7 @@ use crate::{
   source::{Mapping, OriginalLocation},
   vlq::decode,
   with_indices::WithIndices,
-  MapOptions, SourceMap,
+  Error, MapOptions, SourceMap,
 };
 
 // Adding this type because sourceContentLine not happy
@@ -210,29 +211,41 @@ impl<'a> Iterator for SegmentIter<'a> {
     match self.next_segment() {
       Some(segment) => {
         self.nums.clear();
-        decode(segment, &mut self.nums).unwrap();
-        self.generated_column =
-          (i64::from(self.generated_column) + self.nums[0]) as u32;
+        let mut vlq = decode(segment);
+        self.generated_column = (i64::from(self.generated_column)
+          + vlq
+            .next()
+            .unwrap_or_else(|| Err(Error::VlqNoValues))
+            .unwrap()) as u32;
 
         let mut src = None;
         let mut name = None;
 
-        if self.nums.len() > 1 {
-          if self.nums.len() != 4 && self.nums.len() != 5 {
-            panic!("got {} segments, expected 4 or 5", self.nums.len());
-          }
+        if let Some(source_index) = vlq.next() {
+          // if self.nums.len() != 4 && self.nums.len() != 5 {
+          //   panic!("got {} segments, expected 4 or 5", self.nums.len());
+          // }
           self.source_index =
-            (i64::from(self.source_index) + self.nums[1]) as u32;
+            (i64::from(self.source_index) + source_index.unwrap()) as u32;
           src = Some(self.source_index);
-          self.original_line =
-            (i64::from(self.original_line) + self.nums[2]) as u32;
-          self.original_column =
-            (i64::from(self.original_column) + self.nums[3]) as u32;
-
-          if self.nums.len() > 4 {
-            self.name_index =
-              (i64::from(self.name_index) + self.nums[4]) as u32;
-            name = Some(self.name_index);
+          self.original_line = (i64::from(self.original_line)
+            + vlq
+              .next()
+              .unwrap_or_else(|| Err(Error::VlqNoValues))
+              .unwrap()) as u32;
+          self.original_column = (i64::from(self.original_column)
+            + vlq
+              .next()
+              .unwrap_or_else(|| Err(Error::VlqNoValues))
+              .unwrap()) as u32;
+
+          match vlq.next() {
+            Some(name_index) => {
+              self.name_index =
+                (i64::from(self.name_index) + name_index.unwrap()) as u32;
+              name = Some(self.name_index)
+            }
+            None => (),
           }
         }
 

src/vlq.rs

@@ -24,36 +24,59 @@ const B64: [i8; 256] = [
   -1, -1, -1, -1, -1, -1,
 ];
 
-/// Parses a VLQ segment into a pre-allocated `Vec` instead of returning a new allocation.
-pub fn decode(segment: &[u8], rv: &mut ArrayVec<i64, 5>) -> Result<()> {
-  let mut cur = 0;
-  let mut shift = 0;
+pub struct VlqIter<'a> {
+  segment: std::slice::Iter<'a, u8>,
+  cur: i64,
+  shift: u32,
+}
+
+impl<'a> Iterator for VlqIter<'a> {
+  type Item = Result<i64>;
 
-  for c in segment {
-    let enc = i64::from(B64[*c as usize]);
-    let val = enc & 0b11111;
-    let cont = enc >> 5;
-    cur += val.checked_shl(shift).ok_or(Error::VlqOverflow)?;
-    shift += 5;
+  fn next(&mut self) -> Option<Self::Item> {
+    loop {
+      let c = self.segment.next();
+      match c {
+        Some(c) => {
+          let enc = i64::from(B64[*c as usize]);
+          let val = enc & 0b11111;
+          let cont = enc >> 5;
+          self.cur +=
+            match val.checked_shl(self.shift).ok_or(Error::VlqOverflow) {
+              Ok(v) => v,
+              Err(e) => return Some(Err(e)),
+            };
+          self.shift += 5;
 
-    if cont == 0 {
-      let sign = cur & 1;
-      cur >>= 1;
-      if sign != 0 {
-        cur = -cur;
+          if cont == 0 {
+            let sign = self.cur & 1;
+            self.cur >>= 1;
+            if sign != 0 {
+              self.cur = -self.cur;
+            }
+            let result = self.cur;
+            self.cur = 0;
+            self.shift = 0;
+            return Some(Ok(result));
+          }
+        }
+        None => {
+          if self.cur != 0 || self.shift != 0 {
+            return Some(Err(Error::VlqLeftover));
+          } else {
+            return None;
+          }
+        }
       }
-      rv.push(cur);
-      cur = 0;
-      shift = 0;
     }
   }
+}
 
-  if cur != 0 || shift != 0 {
-    Err(Error::VlqLeftover)
-  } else if rv.is_empty() {
-    Err(Error::VlqNoValues)
-  } else {
-    Ok(())
+pub fn decode<'a>(segment: &'a [u8]) -> VlqIter<'a> {
+  VlqIter {
+    segment: segment.iter(),
+    cur: 0,
+    shift: 0,
   }
 }