Reset to start

Author: CPunisher

crates/swc_ecma_parser/src/lexer/capturing.rs

@@ -1,6 +1,7 @@
 use std::mem;
 
 use swc_atoms::Atom;
+use swc_common::BytePos;
 
 use crate::{
     error::Error,
@@ -162,8 +163,8 @@ impl<I: Tokens> Tokens for Capturing<I> {
         self.inner.set_token_value(token_value);
     }
 
-    fn scan_regex(&mut self) -> (TokenAndSpan, Option<(Atom, Atom)>) {
-        let result = self.inner.scan_regex();
+    fn scan_regex(&mut self, start: BytePos) -> (TokenAndSpan, Option<(Atom, Atom)>) {
+        let result = self.inner.scan_regex(start);
         self.capture(result.0);
         result
     }

crates/swc_ecma_parser/src/lexer/mod.rs

@@ -1785,10 +1785,13 @@ impl<'a> Lexer<'a> {
     }
 
     /// Expects current char to be '/'
-    pub(crate) fn read_regexp(&mut self) -> LexResult<(Atom, Atom)> {
-        debug_assert_eq!(self.cur(), Some('/'));
+    pub(crate) fn read_regexp(&mut self, start: BytePos) -> LexResult<(Atom, Atom)> {
+        unsafe {
+            // Safety: start is valid position, and cur() is Some('/')
+            self.input_mut().reset_to(start);
+        }
 
-        let start = self.cur_pos();
+        debug_assert_eq!(self.cur(), Some('/'));
 
         self.bump(); // bump '/'
 

crates/swc_ecma_parser/src/lexer/state.rs

@@ -163,9 +163,8 @@ impl crate::input::Tokens for Lexer<'_> {
         self.state.token_value.take()
     }
 
-    fn scan_regex(&mut self) -> (TokenAndSpan, Option<(Atom, Atom)>) {
-        let start = self.cur_pos();
-        let (token, ret) = match self.read_regexp() {
+    fn scan_regex(&mut self, start: BytePos) -> (TokenAndSpan, Option<(Atom, Atom)>) {
+        let (token, ret) = match self.read_regexp(start) {
             Ok(ret) => (Token::Regex, Some(ret)),
             Err(error) => {
                 self.state.set_token_value(TokenValue::Error(error));

crates/swc_ecma_parser/src/parser/expr.rs

@@ -2592,7 +2592,7 @@ impl<I: Tokens> Parser<I> {
         // Regexp
         debug_assert!(self.input().cur() == Token::Slash || self.input().cur() == Token::DivEq);
 
-        let Some((exp, flags)) = self.input_mut().scan_regex() else {
+        let Some((exp, flags)) = self.input_mut().scan_regex(start) else {
             let error = self.input_mut().expect_error_token_and_bump();
             return Err(error);
         };

crates/swc_ecma_parser/src/parser/input.rs

@@ -59,7 +59,7 @@ pub trait Tokens: Clone + Iterator<Item = TokenAndSpan> {
     fn get_token_value(&self) -> Option<&TokenValue>;
     fn set_token_value(&mut self, token_value: Option<TokenValue>);
 
-    fn scan_regex(&mut self) -> (TokenAndSpan, Option<(Atom, Atom)>);
+    fn scan_regex(&mut self, start: BytePos) -> (TokenAndSpan, Option<(Atom, Atom)>);
     fn scan_jsx_token(&mut self, allow_multiline_jsx_text: bool) -> TokenAndSpan;
     fn scan_jsx_open_el_terminal_token(&mut self) -> TokenAndSpan;
     fn rescan_jsx_open_el_terminal_token(&mut self, reset: BytePos) -> TokenAndSpan;
@@ -139,9 +139,9 @@ impl<I: Tokens> Buffer<I> {
         self.iter.get_token_value()
     }
 
-    pub(crate) fn scan_regex(&mut self) -> Option<(Atom, Atom)> {
+    pub(crate) fn scan_regex(&mut self, start: BytePos) -> Option<(Atom, Atom)> {
         let prev = self.cur;
-        let (t, ret) = self.iter.scan_regex();
+        let (t, ret) = self.iter.scan_regex(start);
         self.prev_span = prev.span;
         self.set_cur(t);
         ret