parser: reduce unnecessary backtracking

[camchenry]

This is a follow-up to #11194.

Now that we are using lookahead in more places in the parser (which is a relatively expensive operation), we want to ensure that we call it as little as possible. Similarly, we also want to avoid try_parse whenever possible. This can be achieved in a few different ways:

1. Add a fast check before doing lookahead
   • Example: self.is_ts && self.lookahead(...) for checking TypeScript-specific syntax
   • Example: self.at(Kind::LCurly) && self.lookahead(...) for checking for a keyword that is only ever preceded by a few specific tokens
2. Only parse forwards: remove backtracking
   • Ideally, we only ever need to look at a single token at a time in order to get the AST. This might not be possible everywhere currently but there are surely some functions that can be written in this way. In code this looks only using eat, at, bump, bump_any methods, and other similar functions and not using: rewind, checkpoint, try_parse, and lookahead.

[overlookmotel]

We could also introduce a more slimmed-down (cheaper) version of lookahead when all you need is to get the next 1 or 2 tokens from lexer and then reset its pointer and errors_pos back to where they were before. Current lookahead does quite a lot of work which isn't required in these cases.

[Boshen]

To win some perf back, we need to rewrite parsing import / export specifiers:

https://github.com/microsoft/TypeScript/blob/b504a1eed45e35b5f54694a1e0a09f35d0a5663c/src/compiler/parser.ts#L8556-L8648

in crates/oxc_parser/src/js/module.rs

+enum ImportOrExportKind {
+    Import,
+    Export,
+}
+
+enum ImportOrExportSpecifier<'a> {
+    ImportSpecifier(ImportSpecifier<'a>),
+    ExportSpecifier(ExportSpecifier<'a>),
+}

+    fn parse_export_specifier(&mut self) -> ExportSpecifier<'a> {
+        self.parse_import_or_export_specifier(ImportOrExportKind::Export)
+    }
+
+    fn parse_import_or_export_specifier(
+        &mut self,
+        kind: ImportOrExportKind,
+    ) -> ImportOrExportSpecifier<'a> {

-    pub(crate) fn parse_import_specifier(
-    fn parse_export_named_specifier(

This is for @camchenry or @leaysgur 😀

[ulrichstark]

We could also introduce a more slimmed-down (cheaper) version of lookahead when all you need is to get the next 1 or 2 tokens from lexer and then reset its pointer and errors_pos back to where they were before. Current lookahead does quite a lot of work which isn't required in these cases.

My attempt at this is in #11358.
+3% parser performance 🎉

[Boshen]

    pub(crate) fn parse_let(&mut self, stmt_ctx: StatementContext) -> Statement<'a> {
        let span = self.start_span();
        let checkpoint = self.checkpoint();
        self.bump_any();
        let peeked = self.cur_kind();

This is on a hot path, tsc uses

    function isLetDeclaration() {
        // In ES6 'let' always starts a lexical declaration if followed by an identifier or {
        // or [.
        return lookAhead(nextTokenIsBindingIdentifierOrStartOfDestructuring);
    }

I wonder whether we can eliminate the peak, or the rewind at least.

[Boshen]

Looking at the code, we need to review all the peeks at the start of a statement or expression, and see if we can remove it.

[Boshen]

https://codspeed.io/oxc-project/oxc/benchmarks/tasks/benchmark/benches/parser.rs::parser::bench_parser::parser%5Bbinder.ts%5D

Need to win back as much perf as we can