refactor(es/parser): Remove EnumKind to reduce compile time (#7137)

Author: kdy1

.github/workflows/CI.yml

@@ -216,9 +216,6 @@ jobs:
           - crate: dbg-swc
             os: ubuntu-latest
             runner: ubuntu-latest
-          - crate: enum_kind
-            os: ubuntu-latest
-            runner: ubuntu-latest
           - crate: from_variant
             os: ubuntu-latest
             runner: ubuntu-latest

Cargo.lock

@@ -25,7 +25,6 @@ verify     = ["swc_ecma_visit"]
 
 [dependencies]
 either         = { version = "1.4" }
-enum_kind      = { version = "0.2.2", path = "../enum_kind" }
 lexical        = { version = "6.1.0", features = ["power-of-two"] }
 num-bigint     = "0.4"
 serde          = { version = "1", features = ["derive"] }

crates/enum_kind/Cargo.toml

@@ -1,6 +1,5 @@
 use std::mem::take;
 
-use enum_kind::Kind;
 use swc_common::{BytePos, Span};
 use tracing::trace;
 
@@ -62,7 +61,7 @@ enum TokenType {
 }
 impl TokenType {
     #[inline]
-    fn before_expr(self) -> bool {
+    const fn before_expr(self) -> bool {
         match self {
             TokenType::JSXName
             | TokenType::JSXTagStart
@@ -760,35 +759,49 @@ impl TokenContexts {
 /// given point in the program is loosely based on sweet.js' approach.
 /// See https://github.com/mozilla/sweet.js/wiki/design
 #[repr(u8)]
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Kind)]
-#[kind(function(is_expr = "bool", preserve_space = "bool"))]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum TokenContext {
     BraceStmt,
-    #[kind(is_expr)]
     BraceExpr,
-    #[kind(is_expr)]
     TplQuasi,
     ParenStmt {
         /// Is this `for` loop?
         is_for_loop: bool,
     },
-    #[kind(is_expr)]
     ParenExpr,
-    #[kind(is_expr, preserve_space)]
     Tpl {
         /// Start of a template literal.
         start: BytePos,
     },
-    #[kind(is_expr)]
     FnExpr,
-    #[kind(is_expr)]
     ClassExpr,
     JSXOpeningTag,
     JSXClosingTag,
-    #[kind(is_expr, preserve_space)]
     JSXExpr,
 }
 
+impl TokenContext {
+    pub(crate) const fn is_expr(&self) -> bool {
+        matches!(
+            self,
+            Self::BraceExpr
+                | Self::TplQuasi
+                | Self::ParenExpr
+                | Self::Tpl { .. }
+                | Self::FnExpr
+                | Self::ClassExpr
+                | Self::JSXExpr
+        )
+    }
+
+    pub(crate) const fn preserve_space(&self) -> bool {
+        match self {
+            Self::Tpl { .. } | Self::JSXExpr => true,
+            _ => false,
+        }
+    }
+}
+
 #[cfg(test)]
 pub(crate) fn with_lexer<F, Ret>(
     syntax: Syntax,

crates/enum_kind/src/expand.rs

@@ -6,7 +6,6 @@ use std::{
     fmt::{self, Debug, Display, Formatter},
 };
 
-use enum_kind::Kind;
 use num_bigint::BigInt as BigIntValue;
 use swc_atoms::{js_word, Atom, JsWord};
 use swc_common::{Span, Spanned};
@@ -16,17 +15,14 @@ use swc_ecma_ast::BinaryOp;
 pub(crate) use self::{AssignOpToken::*, BinOpToken::*, Keyword::*, Token::*};
 use crate::{error::Error, lexer::LexResult};
 
-#[derive(Kind, Clone, PartialEq)]
-#[kind(functions(starts_expr = "bool", before_expr = "bool"))]
+#[derive(Clone, PartialEq)]
 pub enum Token {
     /// Identifier, "null", "true", "false".
     ///
     /// Contains `null` and ``
-    #[kind(delegate)]
     Word(Word),
 
     /// '=>'
-    #[kind(before_expr)]
     Arrow,
 
     /// '#'
@@ -38,93 +34,72 @@ pub enum Token {
     Dot,
 
     /// '...'
-    #[kind(before_expr)]
     DotDotDot,
     /// '!'
-    #[kind(before_expr, starts_expr)]
     Bang,
 
     /// '('
-    #[kind(before_expr, starts_expr)]
     LParen,
     /// ')'
     RParen,
     /// `[`
-    #[kind(before_expr, starts_expr)]
     LBracket,
     /// ']'
     RBracket,
     /// '{'
-    #[kind(before_expr, starts_expr)]
     LBrace,
     /// '}'
     RBrace,
 
     /// ';'
-    #[kind(before_expr)]
     Semi,
     /// ','
-    #[kind(before_expr)]
     Comma,
 
     /// '`'
-    #[kind(starts_expr)]
     BackQuote,
     Template {
         raw: Atom,
         cooked: LexResult<Atom>,
     },
     /// ':'
-    #[kind(before_expr)]
     Colon,
     /// '::'
-    #[kind(before_expr)]
     ColonColon,
     ///
-    #[kind(delegate)]
     BinOp(BinOpToken),
     ///
-    #[kind(before_expr)]
     AssignOp(AssignOpToken),
 
     /// '${'
-    #[kind(before_expr, starts_expr)]
     DollarLBrace,
 
     /// '?'
-    #[kind(before_expr)]
     QuestionMark,
 
     /// `++`
-    #[kind(before_expr, starts_expr)]
     PlusPlus,
     /// `--`
-    #[kind(before_expr, starts_expr)]
     MinusMinus,
 
     /// `~`
-    #[kind(before_expr, starts_expr)]
     Tilde,
 
     /// String literal. Span of this token contains quote.
-    #[kind(starts_expr)]
     Str {
         value: JsWord,
         raw: Atom,
     },
 
     /// Regexp literal.
-    #[kind(starts_expr)]
     Regex(Atom, Atom),
 
     /// TODO: Make Num as enum and separate decimal, binary, ..etc
-    #[kind(starts_expr)]
     Num {
         value: f64,
         raw: Atom,
     },
 
-    #[kind(starts_expr)]
     BigInt {
         value: Box<BigIntValue>,
         raw: Atom,
@@ -133,20 +108,66 @@ pub enum Token {
     JSXName {
         name: JsWord,
     },
-    #[kind(before_expr)]
     JSXText {
         raw: Atom,
     },
-    #[kind(starts_expr)]
     JSXTagStart,
     JSXTagEnd,
 
     Shebang(Atom),
     Error(Error),
 }
 
-#[derive(Kind, Debug, Clone, Copy, Eq, PartialEq, Hash)]
-#[kind(functions(starts_expr = "bool"))]
+impl Token {
+    pub(crate) const fn before_expr(&self) -> bool {
+        match self {
+            Self::Word(w) => w.before_expr(),
+            Self::BinOp(w) => w.before_expr(),
+            Self::Arrow
+            | Self::DotDotDot
+            | Self::Bang
+            | Self::LParen
+            | Self::LBrace
+            | Self::LBracket
+            | Self::Semi
+            | Self::Comma
+            | Self::Colon
+            | Self::ColonColon
+            | Self::AssignOp(..)
+            | Self::DollarLBrace
+            | Self::QuestionMark
+            | Self::PlusPlus
+            | Self::MinusMinus
+            | Self::Tilde
+            | Self::JSXText { .. } => true,
+            _ => false,
+        }
+    }
+
+    pub(crate) const fn starts_expr(&self) -> bool {
+        match self {
+            Self::Word(w) => w.starts_expr(),
+            Self::BinOp(w) => w.starts_expr(),
+            Self::Bang
+            | Self::LParen
+            | Self::LBrace
+            | Self::LBracket
+            | Self::BackQuote
+            | Self::DollarLBrace
+            | Self::PlusPlus
+            | Self::MinusMinus
+            | Self::Tilde
+            | Self::Str { .. }
+            | Self::Regex(..)
+            | Self::Num { .. }
+            | Self::BigInt { .. }
+            | Self::JSXTagStart => true,
+            _ => false,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
 pub enum BinOpToken {
     /// `==`
     EqEq,
@@ -172,10 +193,8 @@ pub enum BinOpToken {
     ZeroFillRShift,
 
     /// `+`
-    #[kind(starts_expr)]
     Add,
     /// `-`
-    #[kind(starts_expr)]
     Sub,
     /// `*`
     Mul,
@@ -210,7 +229,11 @@ pub enum BinOpToken {
 }
 
 impl BinOpToken {
-    pub const fn before_expr(self) -> bool {
+    pub(crate) const fn starts_expr(&self) -> bool {
+        matches!(self, Self::Add | Self::Sub)
+    }
+
+    pub(crate) const fn before_expr(self) -> bool {
         true
     }
 }
@@ -230,23 +253,33 @@ impl Spanned for TokenAndSpan {
     }
 }
 
-#[derive(Kind, Clone, PartialEq, Eq, Hash)]
-#[kind(functions(starts_expr = "bool", before_expr = "bool"))]
+#[derive(Clone, PartialEq, Eq, Hash)]
 pub enum Word {
-    #[kind(delegate)]
     Keyword(Keyword),
 
-    #[kind(starts_expr)]
     Null,
-    #[kind(starts_expr)]
     True,
-    #[kind(starts_expr)]
     False,
 
-    #[kind(starts_expr)]
     Ident(JsWord),
 }
 
+impl Word {
+    pub(crate) const fn before_expr(&self) -> bool {
+        match self {
+            Word::Keyword(k) => k.before_expr(),
+            _ => false,
+        }
+    }
+
+    pub(crate) const fn starts_expr(&self) -> bool {
+        match self {
+            Word::Keyword(k) => k.starts_expr(),
+            _ => true,
+        }
+    }
+}
+
 impl From<JsWord> for Word {
     fn from(i: JsWord) -> Self {
         match i {
@@ -377,40 +410,30 @@ impl Debug for Word {
 }
 
 /// Keywords
-#[derive(Kind, Clone, Copy, PartialEq, Eq, Hash)]
-#[kind(function(before_expr = "bool", starts_expr = "bool"))]
+#[derive(Clone, Copy, PartialEq, Eq, Hash)]
 pub enum Keyword {
     /// Spec says this might be identifier.
-    #[kind(before_expr, starts_expr)]
     Await,
-
     Break,
-    #[kind(before_expr)]
     Case,
     Catch,
     Continue,
     Debugger,
-    #[kind(before_expr)]
     Default_,
-    #[kind(before_expr)]
     Do,
-    #[kind(before_expr)]
     Else,
 
     Finally,
     For,
 
-    #[kind(starts_expr)]
     Function,
 
     If,
 
-    #[kind(before_expr)]
     Return,
 
     Switch,
 
-    #[kind(before_expr, starts_expr)]
     Throw,
 
     Try,
@@ -420,44 +443,68 @@ pub enum Keyword {
     While,
     With,
 
-    #[kind(before_expr, starts_expr)]
     New,
-    #[kind(starts_expr)]
     This,
-    #[kind(starts_expr)]
     Super,
 
-    #[kind(starts_expr)]
     Class,
 
-    #[kind(before_expr)]
     Extends,
 
     Export,
-    #[kind(starts_expr)]
     Import,
 
     /// Spec says this might be identifier.
-    #[kind(before_expr, starts_expr)]
     Yield,
 
-    #[kind(before_expr)]
     In,
-    #[kind(before_expr)]
     InstanceOf,
-
-    #[kind(before_expr, starts_expr)]
     TypeOf,
-
-    #[kind(before_expr, starts_expr)]
     Void,
-
-    #[kind(before_expr, starts_expr)]
     Delete,
 }
 
 impl Keyword {
-    pub(crate) fn into_js_word(self) -> JsWord {
+    pub(crate) const fn before_expr(&self) -> bool {
+        matches!(
+            self,
+            Self::Await
+                | Self::Case
+                | Self::Default_
+                | Self::Do
+                | Self::Else
+                | Self::Return
+                | Self::Throw
+                | Self::New
+                | Self::Extends
+                | Self::Yield
+                | Self::In
+                | Self::InstanceOf
+                | Self::TypeOf
+                | Self::Void
+                | Self::Delete
+        )
+    }
+
+    pub(crate) const fn starts_expr(&self) -> bool {
+        matches!(
+            self,
+            Self::Await
+                | Self::Function
+                | Self::Throw
+                | Self::New
+                | Self::This
+                | Self::Super
+                | Self::Class
+                | Self::Import
+                | Self::Yield
+                | Self::TypeOf
+                | Self::Void
+                | Self::Delete
+        )
+    }
+
+    pub(crate) const fn into_js_word(self) -> JsWord {
         match self {
             Await => js_word!("await"),
             Break => js_word!("break"),