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

`Context` size: 30 bytes -> 4 bytes

Author: CPunisher

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 }

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!('<')));

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()

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();
 

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;
  }

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() });