perf(es/parser): Introduce checkpoint to reduce clone (#11001)

**Description:**

There could be no need to clone entire lexer and parser when calling
`try_parse_xxx` in typescript. Here introduces checkpoints which only
contains necessary data to recover from failed trials. This is also the
prerequisite for #11000. And we
can also remove the `Rc<RefCell<T>>` in the lexer later

I'm not sure the data is completed for correctness. Let's see the test
results.

Author: CPunisher

crates/swc_ecma_lexer/src/common/input.rs

@@ -7,12 +7,17 @@ use crate::{common::syntax::SyntaxFlags, error::Error, lexer};
 /// Clone should be cheap if you are parsing typescript because typescript
 /// syntax requires backtracking.
 pub trait Tokens<TokenAndSpan>: Clone + Iterator<Item = TokenAndSpan> {
+    type Checkpoint;
+
     fn set_ctx(&mut self, ctx: Context);
     fn ctx(&self) -> Context;
     fn ctx_mut(&mut self) -> &mut Context;
     fn syntax(&self) -> SyntaxFlags;
     fn target(&self) -> EsVersion;
 
+    fn checkpoint_save(&self) -> Self::Checkpoint;
+    fn checkpoint_load(&mut self, checkpoint: Self::Checkpoint);
+
     fn start_pos(&self) -> BytePos {
         BytePos(0)
     }

crates/swc_ecma_lexer/src/common/lexer/token.rs

@@ -11,7 +11,6 @@ pub trait TokenFactory<'a, TokenAndSpan, I: Tokens<TokenAndSpan>>: Sized + Parti
         'a,
         I = I,
         Token = Self,
-        Lexer = Self::Lexer,
         TokenAndSpan = TokenAndSpan,
     >;
 

crates/swc_ecma_lexer/src/common/parser/buffer.rs

@@ -19,7 +19,6 @@ pub trait NextTokenAndSpan {
 
 pub trait Buffer<'a> {
     type Token: std::fmt::Debug + PartialEq + Clone + TokenFactory<'a, Self::TokenAndSpan, Self::I>;
-    type Lexer: super::super::lexer::Lexer<'a, Self::TokenAndSpan>;
     type Next: NextTokenAndSpan<Token = Self::Token>;
     type TokenAndSpan: TokenAndSpanTrait<Token = Self::Token>;
     type I: Tokens<Self::TokenAndSpan>;

crates/swc_ecma_lexer/src/common/parser/mod.rs

@@ -52,22 +52,23 @@ pub trait Parser<'a>: Sized + Clone {
     type Token: std::fmt::Debug
         + Clone
         + TokenFactory<'a, Self::TokenAndSpan, Self::I, Buffer = Self::Buffer>;
-    type Lexer: super::lexer::Lexer<'a, Self::TokenAndSpan>;
     type Next: NextTokenAndSpan<Token = Self::Token>;
     type TokenAndSpan: TokenAndSpan<Token = Self::Token>;
     type I: Tokens<Self::TokenAndSpan>;
     type Buffer: self::buffer::Buffer<
         'a,
-        Lexer = Self::Lexer,
         Token = Self::Token,
         TokenAndSpan = Self::TokenAndSpan,
         I = Self::I,
     >;
+    type Checkpoint;
 
     fn input(&self) -> &Self::Buffer;
     fn input_mut(&mut self) -> &mut Self::Buffer;
     fn state(&self) -> &State;
     fn state_mut(&mut self) -> &mut State;
+    fn checkpoint_save(&self) -> Self::Checkpoint;
+    fn checkpoint_load(&mut self, checkpoint: Self::Checkpoint);
 
     #[inline(always)]
     fn with_state<'w>(&'w mut self, state: State) -> WithState<'a, 'w, Self> {

crates/swc_ecma_lexer/src/common/parser/typescript.rs

@@ -79,20 +79,22 @@ where
     if !p.input().syntax().typescript() {
         return Ok(false);
     }
+
     let prev_ignore_error = p.input().get_ctx().contains(Context::IgnoreError);
-    let mut cloned = p.clone();
-    cloned.set_ctx(p.ctx() | Context::IgnoreError);
-    let res = op(&mut cloned);
+    let checkpoint = p.checkpoint_save();
+    p.set_ctx(p.ctx() | Context::IgnoreError);
+    let res = op(p);
     match res {
         Ok(Some(res)) if res => {
-            *p = cloned;
             let mut ctx = p.ctx();
             ctx.set(Context::IgnoreError, prev_ignore_error);
             p.input_mut().set_ctx(ctx);
             Ok(res)
         }
-        Err(..) => Ok(false),
-        _ => Ok(false),
+        _ => {
+            p.checkpoint_load(checkpoint);
+            Ok(false)
+        }
     }
 }
 
@@ -207,12 +209,11 @@ where
     trace_cur!(p, try_parse_ts);
 
     let prev_ignore_error = p.input().get_ctx().contains(Context::IgnoreError);
-    let mut cloned = p.clone();
-    cloned.set_ctx(p.ctx() | Context::IgnoreError);
-    let res = op(&mut cloned);
+    let checkpoint = p.checkpoint_save();
+    p.set_ctx(p.ctx() | Context::IgnoreError);
+    let res = op(p);
     match res {
         Ok(Some(res)) => {
-            *p = cloned;
             trace_cur!(p, try_parse_ts__success_value);
             let mut ctx = p.ctx();
             ctx.set(Context::IgnoreError, prev_ignore_error);
@@ -221,10 +222,12 @@ where
         }
         Ok(None) => {
             trace_cur!(p, try_parse_ts__success_no_value);
+            p.checkpoint_load(checkpoint);
             None
         }
         Err(..) => {
             trace_cur!(p, try_parse_ts__fail);
+            p.checkpoint_load(checkpoint);
             None
         }
     }
@@ -450,9 +453,11 @@ where
     F: FnOnce(&mut P) -> T,
 {
     debug_assert!(p.input().syntax().typescript());
-    let mut cloned = p.clone();
-    cloned.set_ctx(p.ctx() | Context::IgnoreError);
-    op(&mut cloned)
+    let checkpoint = p.checkpoint_save();
+    p.set_ctx(p.ctx() | Context::IgnoreError);
+    let ret = op(p);
+    p.checkpoint_load(checkpoint);
+    ret
 }
 
 /// `tsParseTypeArguments`

crates/swc_ecma_lexer/src/input.rs

@@ -55,6 +55,16 @@ impl Iterator for TokensInput {
 }
 
 impl Tokens<TokenAndSpan> for TokensInput {
+    type Checkpoint = Self;
+
+    fn checkpoint_save(&self) -> Self::Checkpoint {
+        self.clone()
+    }
+
+    fn checkpoint_load(&mut self, checkpoint: Self::Checkpoint) {
+        *self = checkpoint;
+    }
+
     fn set_ctx(&mut self, ctx: Context) {
         if ctx.contains(Context::Module) && !self.module_errors.borrow().is_empty() {
             let mut module_errors = self.module_errors.borrow_mut();
@@ -213,6 +223,16 @@ impl<I: Tokens<TokenAndSpan>> Iterator for Capturing<I> {
 }
 
 impl<I: Tokens<TokenAndSpan>> Tokens<TokenAndSpan> for Capturing<I> {
+    type Checkpoint = I::Checkpoint;
+
+    fn checkpoint_save(&self) -> Self::Checkpoint {
+        self.inner.checkpoint_save()
+    }
+
+    fn checkpoint_load(&mut self, checkpoint: Self::Checkpoint) {
+        self.inner.checkpoint_load(checkpoint);
+    }
+
     #[inline(always)]
     fn set_ctx(&mut self, ctx: Context) {
         self.inner.set_ctx(ctx)
@@ -328,7 +348,6 @@ impl<I: Tokens<TokenAndSpan>> Buffer<I> {
 
 impl<'a, I: Tokens<TokenAndSpan>> crate::common::parser::buffer::Buffer<'a> for Buffer<I> {
     type I = I;
-    type Lexer = super::lexer::Lexer<'a>;
     type Next = TokenAndSpan;
     type Token = Token;
     type TokenAndSpan = TokenAndSpan;

crates/swc_ecma_lexer/src/lexer/state.rs

@@ -641,6 +641,8 @@ impl crate::common::lexer::state::TokenType for TokenType {
 }
 
 impl Tokens<TokenAndSpan> for Lexer<'_> {
+    type Checkpoint = Self;
+
     #[inline]
     fn set_ctx(&mut self, ctx: Context) {
         if ctx.contains(Context::Module) && !self.module_errors.borrow().is_empty() {
@@ -660,6 +662,14 @@ impl Tokens<TokenAndSpan> for Lexer<'_> {
         &mut self.ctx
     }
 
+    fn checkpoint_save(&self) -> Self::Checkpoint {
+        self.clone()
+    }
+
+    fn checkpoint_load(&mut self, checkpoint: Self::Checkpoint) {
+        *self = checkpoint;
+    }
+
     #[inline]
     fn syntax(&self) -> SyntaxFlags {
         self.syntax

crates/swc_ecma_lexer/src/parser/mod.rs

@@ -38,8 +38,8 @@ pub struct Parser<I: Tokens<TokenAndSpan>> {
 
 impl<'a, I: Tokens<TokenAndSpan>> crate::common::parser::Parser<'a> for Parser<I> {
     type Buffer = Buffer<I>;
+    type Checkpoint = Self;
     type I = I;
-    type Lexer = crate::lexer::Lexer<'a>;
     type Next = TokenAndSpan;
     type Token = Token;
     type TokenAndSpan = TokenAndSpan;
@@ -64,6 +64,14 @@ impl<'a, I: Tokens<TokenAndSpan>> crate::common::parser::Parser<'a> for Parser<I
         &mut self.state
     }
 
+    fn checkpoint_save(&self) -> Self::Checkpoint {
+        self.clone()
+    }
+
+    fn checkpoint_load(&mut self, checkpoint: Self::Checkpoint) {
+        *self = checkpoint;
+    }
+
     #[inline(always)]
     fn mark_found_module_item(&mut self) {
         self.found_module_item = true;

crates/swc_ecma_parser/src/lexer/capturing.rs

@@ -68,6 +68,16 @@ impl<I: Iterator<Item = TokenAndSpan>> Iterator for Capturing<I> {
 impl<I: swc_ecma_lexer::common::input::Tokens<TokenAndSpan>>
     swc_ecma_lexer::common::input::Tokens<TokenAndSpan> for Capturing<I>
 {
+    type Checkpoint = I::Checkpoint;
+
+    fn checkpoint_save(&self) -> Self::Checkpoint {
+        self.inner.checkpoint_save()
+    }
+
+    fn checkpoint_load(&mut self, checkpoint: Self::Checkpoint) {
+        self.inner.checkpoint_load(checkpoint);
+    }
+
     fn set_ctx(&mut self, ctx: swc_ecma_lexer::common::context::Context) {
         self.inner.set_ctx(ctx);
     }

crates/swc_ecma_parser/src/lexer/state.rs

@@ -1,12 +1,12 @@
 use std::mem::take;
 
-use swc_common::BytePos;
+use swc_common::{comments::Comments, BytePos};
 use swc_ecma_ast::EsVersion;
 use swc_ecma_lexer::{
     common::{
         lexer::{
             char::CharExt,
-            comments_buffer::{BufferedComment, BufferedCommentKind},
+            comments_buffer::{BufferedComment, BufferedCommentKind, CommentsBuffer},
             state::State as StateTrait,
             LexResult,
         },
@@ -42,7 +42,35 @@ pub struct State {
     token_type: Option<Token>,
 }
 
-impl swc_ecma_lexer::common::input::Tokens<TokenAndSpan> for Lexer<'_> {
+pub struct LexerCheckpoint<'a> {
+    comments: Option<&'a dyn Comments>,
+    comments_buffer: Option<CommentsBuffer>,
+    state: State,
+    ctx: Context,
+    input_last_pos: BytePos,
+}
+
+impl<'a> swc_ecma_lexer::common::input::Tokens<TokenAndSpan> for Lexer<'a> {
+    type Checkpoint = LexerCheckpoint<'a>;
+
+    fn checkpoint_save(&self) -> Self::Checkpoint {
+        Self::Checkpoint {
+            comments: self.comments,
+            comments_buffer: self.comments_buffer.clone(),
+            state: self.state.clone(),
+            ctx: self.ctx,
+            input_last_pos: self.input.last_pos(),
+        }
+    }
+
+    fn checkpoint_load(&mut self, checkpoint: Self::Checkpoint) {
+        self.comments = checkpoint.comments;
+        self.comments_buffer = checkpoint.comments_buffer;
+        self.state = checkpoint.state;
+        self.ctx = checkpoint.ctx;
+        unsafe { self.input.reset_to(checkpoint.input_last_pos) };
+    }
+
     #[inline]
     fn set_ctx(&mut self, ctx: Context) {
         if ctx.contains(Context::Module) && !self.module_errors.borrow().is_empty() {