Introduce fast_slice to avoid unnecessary memory write

Author: CPunisher

crates/swc_common/src/input.rs

@@ -44,6 +44,35 @@ impl<'a> StringInput<'a> {
         self.iter.as_str()
     }
 
+    #[inline(always)]
+    /// Compared to [StringInput::slice], this function doesn't set
+    /// `self.last_pos = end` because in most cases this property has been
+    /// satisfied but the compiler cannot optimize it.
+    ///
+    /// Caution: This function should only be used internally and will be
+    /// changed in the future.
+    ///
+    /// # Safety
+    /// - start should be less than or equal to end.
+    /// - start and end should be in the valid range of input.
+    pub unsafe fn fast_slice(&mut self, start: BytePos, end: BytePos) -> &'a str {
+        debug_assert!(self.last_pos == end);
+
+        debug_assert!(start <= end, "Cannot slice {start:?}..{end:?}");
+        let s = self.orig;
+
+        let start_idx = (start - self.orig_start).0 as usize;
+        let end_idx = (end - self.orig_start).0 as usize;
+
+        debug_assert!(end_idx <= s.len());
+
+        let ret = unsafe { s.get_unchecked(start_idx..end_idx) };
+
+        self.iter = unsafe { s.get_unchecked(end_idx..) }.chars();
+
+        ret
+    }
+
     #[inline]
     pub fn bump_bytes(&mut self, n: usize) {
         unsafe {

crates/swc_ecma_parser/src/lexer/mod.rs

@@ -142,7 +142,14 @@ impl<'a> Lexer<'a> {
     }
 
     #[inline(always)]
+    /// This function should be used to replace [Lexer::input_slice_and_move] if
+    /// the `end` comes from [Lexer::cur_pos] or [Lexer::last_pos]
     unsafe fn input_slice(&mut self, start: BytePos, end: BytePos) -> &'a str {
+        self.input.fast_slice(start, end)
+    }
+
+    #[inline(always)]
+    unsafe fn input_slice_and_move(&mut self, start: BytePos, end: BytePos) -> &'a str {
         self.input.slice(start, end)
     }
 
@@ -638,7 +645,7 @@ impl<'a> Lexer<'a> {
                 let end = self.input().end_pos();
 
                 if self.comments_buffer().is_some() {
-                    let s = unsafe { self.input_slice(slice_start, end) };
+                    let s = unsafe { self.input_slice_and_move(slice_start, end) };
                     let cmt = swc_common::comments::Comment {
                         kind: swc_common::comments::CommentKind::Line,
                         span: Span::new_with_checked(start, end),
@@ -1045,7 +1052,7 @@ impl<'a> Lexer<'a> {
             let lazy_integer = self.read_number_no_dot_as_str::<10>()?;
             let s = unsafe {
                 // Safety: We got both start and end position from `self.input`
-                self.input_slice(lazy_integer.start, lazy_integer.end)
+                self.input_slice_and_move(lazy_integer.start, lazy_integer.end)
             };
 
             // legacy octal number is not allowed in bigint.
@@ -1157,7 +1164,7 @@ impl<'a> Lexer<'a> {
             let raw = remove_underscore(raw, has_underscore);
             raw.parse().expect("failed to parse float literal")
         } else {
-            let s = unsafe { self.input_slice(lazy_integer.start, lazy_integer.end) };
+            let s = unsafe { self.input_slice_and_move(lazy_integer.start, lazy_integer.end) };
             let s = remove_underscore(s, has_underscore);
             parse_integer::<10>(&s)
         };
@@ -1224,7 +1231,7 @@ impl<'a> Lexer<'a> {
 
         let s = unsafe {
             // Safety: We got both start and end position from `self.input`
-            self.input_slice(lazy_integer.start, lazy_integer.end)
+            self.input_slice_and_move(lazy_integer.start, lazy_integer.end)
         };
         if self.eat(b'n') {
             let end = self.cur_pos();
@@ -1873,7 +1880,7 @@ impl<'a> Lexer<'a> {
                         let s = unsafe {
                             // Safety: start and end are valid position because we got them from
                             // `self.input`
-                            self.input_slice(slice_start, start)
+                            self.input_slice_and_move(slice_start, start)
                         };
                         buf.push_str(s);
                         unsafe {