perf: FullMappingsEncoder

Author: SyMind

src/encoder.rs

@@ -3,40 +3,75 @@ use crate::Mapping;
 const B64_CHARS: &[u8] =
   b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
-pub fn encode_vlq(out: &mut Vec<u8>, a: u32, b: u32) {
+/// Encode a VLQ diff (a relative to b) into `out`.
+///
+/// Uses a stack buffer to batch the write, avoiding per-byte `Vec::push`
+/// bounds checks.
+#[inline(always)]
+fn encode_vlq(out: &mut Vec<u8>, a: u32, b: u32) {
   let mut num = if a >= b {
     (a - b) << 1
   } else {
     ((b - a) << 1) + 1
   };
 
+  // A VLQ for u32 needs at most ceil(32/5)+1 = 7 base64 characters.
+  let mut buf = [0u8; 7];
+  let mut len = 0;
+
   loop {
     let mut digit = num & 0b11111;
     num >>= 5;
     if num > 0 {
       digit |= 1 << 5;
     }
-    out.push(B64_CHARS[digit as usize]);
+    buf[len] = B64_CHARS[digit as usize];
+    len += 1;
     if num == 0 {
       break;
     }
   }
+
+  out.extend_from_slice(&buf[..len]);
 }
 
-pub(crate) trait MappingsEncoder {
-  fn encode(&mut self, mapping: &Mapping);
-  fn drain(&mut self) -> String;
+/// A source map mappings encoder that eliminates dynamic dispatch by using
+/// an enum instead of `Box<dyn Trait>`.
+pub(crate) enum MappingsEncoder {
+  Full(FullMappingsEncoder),
+  LinesOnly(LinesOnlyMappingsEncoder),
 }
 
-pub fn create_encoder(columns: bool) -> Box<dyn MappingsEncoder> {
-  if columns {
-    Box::new(FullMappingsEncoder::new())
-  } else {
-    Box::new(LinesOnlyMappingsEncoder::new())
+impl MappingsEncoder {
+  /// Create a new encoder. `columns: true` produces full mappings,
+  /// `columns: false` produces lines-only mappings.
+  #[inline]
+  pub fn new(columns: bool) -> Self {
+    if columns {
+      Self::Full(FullMappingsEncoder::new())
+    } else {
+      Self::LinesOnly(LinesOnlyMappingsEncoder::new())
+    }
+  }
+
+  #[inline]
+  pub fn encode(&mut self, mapping: &Mapping) {
+    match self {
+      Self::Full(enc) => enc.encode(mapping),
+      Self::LinesOnly(enc) => enc.encode(mapping),
+    }
+  }
+
+  #[inline]
+  pub fn drain(&mut self) -> String {
+    match self {
+      Self::Full(enc) => enc.drain(),
+      Self::LinesOnly(enc) => enc.drain(),
+    }
   }
 }
 
-struct FullMappingsEncoder {
+pub(crate) struct FullMappingsEncoder {
   current_line: u32,
   current_column: u32,
   current_original_line: u32,
@@ -50,7 +85,7 @@ struct FullMappingsEncoder {
 }
 
 impl FullMappingsEncoder {
-  pub fn new() -> Self {
+  fn new() -> Self {
     Self {
       current_line: 1,
       current_column: 0,
@@ -64,9 +99,7 @@ impl FullMappingsEncoder {
       mappings: Default::default(),
     }
   }
-}
 
-impl MappingsEncoder for FullMappingsEncoder {
   fn encode(&mut self, mapping: &Mapping) {
     if self.active_mapping && self.current_line == mapping.generated_line {
       // A mapping is still active
@@ -89,8 +122,10 @@ impl MappingsEncoder for FullMappingsEncoder {
     }
 
     if self.current_line < mapping.generated_line {
-      (0..mapping.generated_line - self.current_line)
-        .for_each(|_| self.mappings.push(b';'));
+      let delta = (mapping.generated_line - self.current_line) as usize;
+      self
+        .mappings
+        .extend(std::iter::repeat_n(b';', delta));
       self.current_line = mapping.generated_line;
       self.current_column = 0;
       self.initial = false;
@@ -173,9 +208,7 @@ impl LinesOnlyMappingsEncoder {
       mappings: Default::default(),
     }
   }
-}
 
-impl MappingsEncoder for LinesOnlyMappingsEncoder {
   fn encode(&mut self, mapping: &Mapping) {
     if let Some(original) = &mapping.original {
       if self.last_written_line == mapping.generated_line {
@@ -196,9 +229,9 @@ impl MappingsEncoder for LinesOnlyMappingsEncoder {
       if original.source_index == self.current_source_index {
         if original.original_line == self.current_original_line + 1 {
           self.current_original_line = original.original_line;
-          self.mappings.extend(b"AACA");
+          self.mappings.extend_from_slice(b"AACA");
         } else {
-          self.mappings.extend(b"AA");
+          self.mappings.extend_from_slice(b"AA");
           encode_vlq(
             &mut self.mappings,
             original.original_line,
@@ -208,7 +241,7 @@ impl MappingsEncoder for LinesOnlyMappingsEncoder {
           self.mappings.push(b'A');
         }
       } else {
-        self.mappings.extend(b"A");
+        self.mappings.push(b'A');
         encode_vlq(
           &mut self.mappings,
           original.source_index,

src/helpers.rs

@@ -9,7 +9,7 @@ use rustc_hash::FxHashMap as HashMap;
 
 use crate::{
   decoder::MappingsDecoder,
-  encoder::create_encoder,
+  encoder::MappingsEncoder,
   linear_map::LinearMap,
   object_pool::ObjectPool,
   source::{Mapping, OriginalLocation},
@@ -23,7 +23,7 @@ pub fn get_map<'a>(
   stream: &'a dyn Stream,
   options: &MapOptions,
 ) -> (GeneratedInfo, Option<SourceMap>) {
-  let mut mappings_encoder = create_encoder(options.columns);
+  let mut mappings_encoder = MappingsEncoder::new(options.columns);
   let mut sources: Vec<String> = Vec::new();
   let mut sources_content: Vec<Arc<str>> = Vec::new();
   let mut names: Vec<String> = Vec::new();
@@ -168,7 +168,7 @@ pub fn decode_mappings(
 
 /// Encodes the given iterator of `Mapping` items into a `String`.
 pub fn encode_mappings(mappings: impl Iterator<Item = Mapping>) -> String {
-  let mut encoder = create_encoder(true);
+  let mut encoder = MappingsEncoder::new(true);
   mappings.for_each(|mapping| encoder.encode(&mapping));
   encoder.drain()
 }
@@ -1257,7 +1257,7 @@ pub fn stream_and_get_source_and_map<'a>(
   on_source: OnSource<'_, 'a>,
   on_name: OnName<'_, 'a>,
 ) -> (GeneratedInfo, Option<SourceMap>) {
-  let mut mappings_encoder = create_encoder(options.columns);
+  let mut mappings_encoder = MappingsEncoder::new(options.columns);
   let mut sources: Vec<String> = Vec::new();
   let mut sources_content: Vec<Arc<str>> = Vec::new();
   let mut names: Vec<String> = Vec::new();