Improve mappings

Author: hyf0

src/mappings.rs

@@ -2,14 +2,51 @@ use crate::{chunk::Chunk, locator::Locator, TextSize};
 #[derive(Debug)]
 
 pub struct Segment {
-    // column in the generated code
-    /// `dst_column` is calculated based on utf-16.
-    pub dst_column: i64,
-    pub source_index: i64,
-    pub src_line: i64,
-    /// `src_column` is calculated based on utf-16.
-    pub src_column: i64,
-    pub name_index: Option<i64>,
+    /// [dst_column, source_index, src_line, src_column]
+    /// - `dst_column` is calculated based on utf-16.
+    /// - `src_column` is calculated based on utf-16.
+    inner: [i64; 4],
+    name_index: Option<i64>,
+}
+
+impl Segment {
+    pub fn new(
+        dst_column: i64,
+        source_index: i64,
+        src_line: i64,
+        src_column: i64,
+        name_index: Option<i64>,
+    ) -> Self {
+        Self {
+            inner: [
+                dst_column.into(),
+                source_index.into(),
+                src_line.into(),
+                src_column.into(),
+            ],
+            name_index: name_index.map(|n| n.into()),
+        }
+    }
+
+    pub fn dst_column(&self) -> i64 {
+        self.inner[0]
+    }
+
+    pub fn source_index(&self) -> i64 {
+        self.inner[1]
+    }
+
+    pub fn src_line(&self) -> i64 {
+        self.inner[2]
+    }
+
+    pub fn src_column(&self) -> i64 {
+        self.inner[3]
+    }
+
+    pub fn name_index(&self) -> Option<i64> {
+        self.name_index
+    }
 }
 
 #[derive(Debug)]
@@ -40,13 +77,13 @@ impl Mappings {
         let mut loc = locator.locate(chunk.start());
         if let Some(edited_content) = &chunk.edited_content {
             if !edited_content.is_empty() {
-                let segment = Segment {
-                    dst_column: self.generated_code_column.into(),
-                    source_index: source_index.into(),
-                    src_line: loc.line.into(),
-                    src_column: loc.column.into(),
-                    name_index: name_index.map(|n| n.into()),
-                };
+                let segment = Segment::new(
+                    self.generated_code_column.into(),
+                    source_index.into(),
+                    loc.line.into(),
+                    loc.column.into(),
+                    name_index.map(|n| n.into()),
+                );
                 self.add_segment_to_current_line(segment);
             }
             self.advance(edited_content);
@@ -63,13 +100,13 @@ impl Mappings {
                     _ => {
                         if new_line {
                             new_line = false;
-                            let segment = Segment {
-                                dst_column: self.generated_code_column.into(),
-                                source_index: source_index.into(),
-                                src_line: loc.line.into(),
-                                src_column: loc.column.into(),
-                                name_index: None,
-                            };
+                            let segment = Segment::new(
+                                self.generated_code_column.into(),
+                                source_index.into(),
+                                loc.line.into(),
+                                loc.column.into(),
+                                None,
+                            );
                             self.add_segment_to_current_line(segment);
                         }
 
@@ -87,7 +124,7 @@ impl Mappings {
             return;
         }
         let mut lines = content.split('\n');
-        
+
         // SAFETY: In any cases, lines would have at least one element.
         // "".split('\n') would create `[""]`.
         // "\n".split('\n') would create `["", ""]`.
@@ -111,43 +148,28 @@ impl Mappings {
 
     pub fn encoded(&self) -> String {
         let mut encoded_mappings = String::new();
-        let mut last_segment = Segment {
-            dst_column: 0,
-            source_index: 0,
-            src_line: 0,
-            src_column: 0,
-            name_index: None,
-        };
+        // [dst_column, source_index, src_line, src_column]
+        let mut last_segment = [0i64, 0, 0, 0];
+        let mut last_name_idx = 0i64;
         for (line_idx, line) in self.raw.iter().enumerate() {
-            last_segment.dst_column = 0;
+            last_segment[0] = 0;
             for (segment_idx, segment) in line.iter().enumerate() {
-                encode_vlq(
-                    segment.dst_column - last_segment.dst_column,
-                    &mut encoded_mappings,
-                );
-                encode_vlq(
-                    segment.source_index - last_segment.source_index,
-                    &mut encoded_mappings,
-                );
-                encode_vlq(
-                    segment.src_line - last_segment.src_line,
-                    &mut encoded_mappings,
-                );
-                encode_vlq(
-                    segment.src_column - last_segment.src_column,
-                    &mut encoded_mappings,
-                );
-                last_segment.dst_column = segment.dst_column;
-                last_segment.source_index = segment.source_index;
-                last_segment.src_line = segment.src_line;
-                last_segment.src_column = segment.src_column;
-                if let Some(name_index) = segment.name_index {
-                    encode_vlq(
-                        name_index - last_segment.name_index.unwrap_or_default(),
-                        &mut encoded_mappings,
-                    );
-                    last_segment.name_index = segment.name_index;
+                let diff = [
+                    segment.dst_column() - last_segment[0],
+                    segment.source_index() - last_segment[1],
+                    segment.src_line() - last_segment[2],
+                    segment.src_column() - last_segment[3],
+                ];
+                diff.into_iter().for_each(|diff| {
+                    encode_vlq(diff, &mut encoded_mappings);
+                });
+                last_segment = segment.inner;
+
+                if let Some(name_index) = segment.name_index() {
+                    encode_vlq(name_index - last_name_idx, &mut encoded_mappings);
+                    last_name_idx = name_index;
                 }
+
                 if segment_idx != line.len() - 1 {
                     encoded_mappings.push(',');
                 }