perf(es/parser): Use bitflags to reduce parser context size (#10367)

`Context` size: 30 bytes -> 4 bytes

Author: CPunisher

Diff for: Cargo.lock

@@ -25,6 +25,7 @@ typescript    = []
 verify        = ["swc_ecma_visit"]
 
 [dependencies]
+bitflags    = { workspace = true }
 either      = { workspace = true }
 num-bigint  = { workspace = true }
 num-traits  = { workspace = true }

Diff for: crates/swc_ecma_parser/Cargo.toml

@@ -663,7 +663,9 @@ impl Lexer<'_> {
         let c = self.cur().unwrap();
         self.bump();
 
-        if self.syntax.typescript() && self.ctx.in_type && !self.ctx.should_not_lex_lt_or_gt_as_type
+        if self.syntax.typescript()
+            && self.ctx.contains(Context::InType)
+            && !self.ctx.contains(Context::ShouldNotLexLtOrGtAsType)
         {
             if c == '<' {
                 return Ok(Some(tok!('<')));

Diff for: crates/swc_ecma_parser/src/lexer/mod.rs

@@ -782,7 +782,7 @@ mod tests {
             let vec = panic::catch_unwind(|| {
                 crate::with_test_sess(case, |_, input| {
                     let mut l = Lexer::new(Syntax::default(), Default::default(), input, None);
-                    l.ctx.strict = strict;
+                    l.ctx.set(Context::Strict, strict);
                     Ok(l.map(|ts| ts.token).collect::<Vec<_>>())
                 })
                 .unwrap()

Diff for: crates/swc_ecma_parser/src/lexer/number.rs

@@ -124,7 +124,7 @@ impl From<TokenKind> for TokenType {
 impl Tokens for Lexer<'_> {
     #[inline]
     fn set_ctx(&mut self, ctx: Context) {
-        if ctx.module && !self.module_errors.borrow().is_empty() {
+        if ctx.contains(Context::Module) && !self.module_errors.borrow().is_empty() {
             let mut module_errors = self.module_errors.borrow_mut();
             self.errors.borrow_mut().append(&mut *module_errors);
         }
@@ -181,7 +181,7 @@ impl Tokens for Lexer<'_> {
     }
 
     fn add_module_mode_error(&self, error: Error) {
-        if self.ctx.module {
+        if self.ctx.contains(Context::Module) {
             self.add_error(error);
             return;
         }
@@ -284,7 +284,10 @@ impl Lexer<'_> {
 
         self.state.start = *start;
 
-        if self.syntax.jsx() && !self.ctx.in_property_name && !self.ctx.in_type {
+        if self.syntax.jsx()
+            && !self.ctx.contains(Context::InPropertyName)
+            && !self.ctx.contains(Context::InType)
+        {
             //jsx
             if self.state.context.current() == Some(TokenContext::JSXExpr) {
                 return self.read_jsx_token();
@@ -852,8 +855,8 @@ pub(crate) fn lex(syntax: Syntax, s: &'static str) -> Vec<TokenAndSpan> {
 #[cfg(test)]
 pub(crate) fn lex_module_errors(syntax: Syntax, s: &'static str) -> Vec<Error> {
     with_lexer(syntax, Default::default(), s, |l| {
-        l.ctx.strict = true;
-        l.ctx.module = true;
+        l.ctx.insert(Context::Module);
+        l.ctx.insert(Context::Strict);
 
         let _: Vec<_> = l.collect();
 

Diff for: crates/swc_ecma_parser/src/lexer/state.rs

@@ -16,7 +16,7 @@ use super::{comments_buffer::BufferedComment, whitespace::SkipWhitespace, Char,
 use crate::{
     error::{Error, SyntaxError},
     lexer::comments_buffer::BufferedCommentKind,
-    Tokens,
+    Context, Tokens,
 };
 
 impl Lexer<'_> {
@@ -104,7 +104,7 @@ impl Lexer<'_> {
     #[cold]
     #[inline(never)]
     pub(super) fn emit_error_span(&mut self, span: Span, kind: SyntaxError) {
-        if self.ctx.ignore_error {
+        if self.ctx.contains(Context::IgnoreError) {
             return;
         }
 
@@ -123,7 +123,7 @@ impl Lexer<'_> {
     #[cold]
     #[inline(never)]
     pub(super) fn emit_strict_mode_error_span(&mut self, span: Span, kind: SyntaxError) {
-        if self.ctx.strict {
+        if self.ctx.contains(Context::Strict) {
             self.emit_error_span(span, kind);
             return;
         }

Diff for: crates/swc_ecma_parser/src/lexer/util.rs

@@ -369,79 +369,76 @@ pub struct EsSyntax {
     pub explicit_resource_management: bool,
 }
 
-/// Syntactic context.
-#[derive(Debug, Clone, Copy, Default)]
-pub struct Context {
-    /// `true` while backtracking
-    ignore_error: bool,
+use bitflags::bitflags;
 
-    /// Is in module code?
-    module: bool,
-    can_be_module: bool,
-    strict: bool,
+bitflags! {
+    #[derive(Debug, Clone, Copy, Default)]
+    pub struct Context: u32 {
 
-    expr_ctx: ExpressionContext,
+        /// `true` while backtracking
+        const IgnoreError = 1 << 0;
 
-    include_in_expr: bool,
-    /// If true, await expression is parsed, and "await" is treated as a
-    /// keyword.
-    in_async: bool,
-    /// If true, yield expression is parsed, and "yield" is treated as a
-    /// keyword.
-    in_generator: bool,
+        /// Is in module code?
+        const Module = 1 << 1;
+        const CanBeModule = 1 << 2;
+        const Strict = 1 << 3;
 
-    /// If true, await is treated as a keyword.
-    in_static_block: bool,
+        const ForLoopInit = 1 << 4;
+        const ForAwaitLoopInit = 1 << 5;
 
-    is_continue_allowed: bool,
-    is_break_allowed: bool,
+        const IncludeInExpr = 1 << 6;
+        /// If true, await expression is parsed, and "await" is treated as a
+        /// keyword.
+        const InAsync = 1 << 7;
+        /// If true, yield expression is parsed, and "yield" is treated as a
+        /// keyword.
+        const InGenerator = 1 << 8;
 
-    in_type: bool,
-    /// Typescript extension.
-    should_not_lex_lt_or_gt_as_type: bool,
-    /// Typescript extension.
-    in_declare: bool,
+        /// If true, await is treated as a keyword.
+        const InStaticBlock = 1 << 9;
 
-    /// If true, `:` should not be treated as a type annotation.
-    in_cond_expr: bool,
-    will_expect_colon_for_cond: bool,
+        const IsContinueAllowed = 1 << 10;
+        const IsBreakAllowed = 1 << 11;
 
-    in_class: bool,
+        const InType = 1 << 12;
+        /// Typescript extension.
+        const ShouldNotLexLtOrGtAsType = 1 << 13;
+        /// Typescript extension.
+        const InDeclare = 1 << 14;
 
-    in_class_field: bool,
+        /// If true, `:` should not be treated as a type annotation.
+        const InCondExpr = 1 << 15;
+        const WillExpectColonForCond = 1 << 16;
 
-    in_function: bool,
+        const InClass = 1 << 17;
 
-    /// This indicates current scope or the scope out of arrow function is
-    /// function declaration or function expression or not.
-    inside_non_arrow_function_scope: bool,
+        const InClassField = 1 << 18;
 
-    in_parameters: bool,
+        const InFunction = 1 << 19;
 
-    has_super_class: bool,
+        /// This indicates current scope or the scope out of arrow function is
+        /// function declaration or function expression or not.
+        const InsideNonArrowFunctionScope = 1 << 20;
 
-    in_property_name: bool,
+        const InParameters = 1 << 21;
 
-    in_forced_jsx_context: bool,
+        const HasSuperClass = 1 << 22;
 
-    // If true, allow super.x and super[x]
-    allow_direct_super: bool,
+        const InPropertyName = 1 << 23;
 
-    ignore_else_clause: bool,
+        const InForcedJsxContext = 1 << 24;
 
-    disallow_conditional_types: bool,
+        // If true, allow super.x and super[x]
+        const AllowDirectSuper = 1 << 25;
 
-    allow_using_decl: bool,
+        const IgnoreElseClause = 1 << 26;
 
-    top_level: bool,
-}
+        const DisallowConditionalTypes = 1 << 27;
+
+        const AllowUsingDecl = 1 << 28;
 
-#[derive(Debug, Clone, Copy, Default)]
-struct ExpressionContext {
-    // TODO:
-    // - include_in
-    for_loop_init: bool,
-    for_await_loop_init: bool,
+        const TopLevel = 1 << 29;
+    }
 }
 
 #[cfg(test)]
@@ -499,7 +496,7 @@ macro_rules! expose {
 
 expose!(parse_file_as_expr, Box<Expr>, |p| {
     // This allow to parse `import.meta`
-    p.input().ctx.can_be_module = true;
+    p.input().ctx.insert(Context::CanBeModule);
     p.parse_expr()
 });
 expose!(parse_file_as_module, Module, |p| { p.parse_module() });