refactor(ast)!: replace Modifiers with declare and const on EnumDeclaration (#3845)

Author: Boshen

crates/oxc_ast/src/ast/mod.rs

@@ -241,6 +241,10 @@ impl<'a> Modifiers<'a> {
         self.0.as_ref().and_then(|modifiers| modifiers.iter().find(|modifier| f(modifier)))
     }
 
+    pub fn is_contains_const(&self) -> bool {
+        self.contains(ModifierKind::Const)
+    }
+
     pub fn is_contains_declare(&self) -> bool {
         self.contains(ModifierKind::Declare)
     }

crates/oxc_ast/src/ast/ts.rs

@@ -55,8 +55,8 @@ pub struct TSEnumDeclaration<'a> {
     pub span: Span,
     pub id: BindingIdentifier<'a>,
     pub members: Vec<'a, TSEnumMember<'a>>,
-    /// Valid Modifiers: `const`, `export`, `declare`
-    pub modifiers: Modifiers<'a>,
+    pub r#const: bool,
+    pub declare: bool,
     pub scope_id: Cell<Option<ScopeId>>,
 }
 

crates/oxc_ast/src/ast_builder.rs

@@ -1883,10 +1883,11 @@ impl<'a> AstBuilder<'a> {
         span: Span,
         id: BindingIdentifier<'a>,
         members: Vec<'a, TSEnumMember<'a>>,
-        modifiers: Modifiers<'a>,
+        r#const: bool,
+        declare: bool,
     ) -> Declaration<'a> {
         Declaration::TSEnumDeclaration(
-            self.alloc(TSEnumDeclaration::new(span, id, members, modifiers)),
+            self.alloc(TSEnumDeclaration::new(span, id, members, r#const, declare)),
         )
     }
 

crates/oxc_ast/src/ast_impl/js.rs

@@ -710,7 +710,7 @@ impl<'a> Declaration<'a> {
             Declaration::VariableDeclaration(decl) => decl.declare,
             Declaration::FunctionDeclaration(decl) => decl.declare,
             Declaration::ClassDeclaration(decl) => decl.declare,
-            Declaration::TSEnumDeclaration(decl) => decl.modifiers.is_contains_declare(),
+            Declaration::TSEnumDeclaration(decl) => decl.declare,
             Declaration::TSTypeAliasDeclaration(decl) => decl.modifiers.is_contains_declare(),
             Declaration::TSModuleDeclaration(decl) => decl.modifiers.is_contains_declare(),
             Declaration::TSInterfaceDeclaration(decl) => decl.modifiers.is_contains_declare(),

crates/oxc_ast/src/ast_impl/ts.rs

@@ -19,17 +19,19 @@ impl<'a> TSEnumDeclaration<'a> {
         span: Span,
         id: BindingIdentifier<'a>,
         members: Vec<'a, TSEnumMember<'a>>,
-        modifiers: Modifiers<'a>,
+        r#const: bool,
+        declare: bool,
     ) -> Self {
-        Self { span, id, members, modifiers, scope_id: Cell::default() }
+        Self { span, id, members, r#const, declare, scope_id: Cell::default() }
     }
 }
 
 impl<'a> Hash for TSEnumDeclaration<'a> {
     fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
         self.id.hash(state);
         self.members.hash(state);
-        self.modifiers.hash(state);
+        self.r#const.hash(state);
+        self.declare.hash(state);
     }
 }
 

crates/oxc_codegen/src/gen.rs

@@ -3357,13 +3357,10 @@ impl<'a, const MINIFY: bool> Gen<MINIFY> for TSInterfaceHeritage<'a> {
 impl<'a, const MINIFY: bool> Gen<MINIFY> for TSEnumDeclaration<'a> {
     fn gen(&self, p: &mut Codegen<{ MINIFY }>, ctx: Context) {
         p.print_indent();
-        if self.modifiers.contains(ModifierKind::Export) {
-            p.print_str(b"export ");
-        }
-        if self.modifiers.contains(ModifierKind::Declare) {
+        if self.declare {
             p.print_str(b"declare ");
         }
-        if self.modifiers.contains(ModifierKind::Const) {
+        if self.r#const {
             p.print_str(b"const ");
         }
         p.print_space_before_identifier();

crates/oxc_isolated_declarations/src/enum.rs

@@ -91,11 +91,17 @@ impl<'a> IsolatedDeclarations<'a> {
             members.push(member);
         }
         let mut modifiers = self.modifiers_declare();
-        if decl.modifiers.contains(ModifierKind::Const) {
+        if decl.r#const {
             modifiers.add_modifier(Modifier { span: SPAN, kind: ModifierKind::Const });
         }
 
-        Some(self.ast.ts_enum_declaration(decl.span, self.ast.copy(&decl.id), members, modifiers))
+        Some(self.ast.ts_enum_declaration(
+            decl.span,
+            self.ast.copy(&decl.id),
+            members,
+            modifiers.is_contains_const(),
+            modifiers.is_contains_declare(),
+        ))
     }
 
     /// Evaluate the expression to a constant value.

crates/oxc_linter/src/rules/oxc/no_const_enum.rs

@@ -1,4 +1,4 @@
-use oxc_ast::{ast::ModifierKind, AstKind};
+use oxc_ast::AstKind;
 use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
@@ -41,17 +41,16 @@ declare_oxc_lint!(
 impl Rule for NoConstEnum {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
         if let AstKind::TSEnumDeclaration(enum_decl) = node.kind() {
-            let Some(const_enum) = enum_decl
-                .modifiers
-                .find_where(|modifier| matches!(modifier.kind, ModifierKind::Const))
-            else {
+            if !enum_decl.r#const {
                 return;
-            };
+            }
 
-            ctx.diagnostic_with_fix(no_const_enum_diagnostic(const_enum.span), |fixer| {
+            let span = Span::new(enum_decl.span.start, enum_decl.span.start + 5);
+
+            ctx.diagnostic_with_fix(no_const_enum_diagnostic(span), |fixer| {
                 // const enum Color { Red, Green, Blue }
                 // ^
-                let start = const_enum.span.start;
+                let start = span.start;
 
                 // const enum Color { Red, Green, Blue }
                 // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

crates/oxc_parser/src/ts/statement.rs

@@ -8,6 +8,7 @@ use super::{
     types::ModifierFlags,
 };
 use crate::{
+    diagnostics,
     js::{FunctionKind, VariableDeclarationContext, VariableDeclarationParent},
     lexer::Kind,
     list::{NormalList, SeparatedList},
@@ -25,14 +26,30 @@ impl<'a> ParserImpl<'a> {
     pub(crate) fn parse_ts_enum_declaration(
         &mut self,
         span: Span,
-        modifiers: Modifiers<'a>,
+        modifiers: &Modifiers<'a>,
     ) -> Result<Declaration<'a>> {
         self.bump_any(); // bump `enum`
 
         let id = self.parse_binding_identifier()?;
         let members = TSEnumMemberList::parse(self)?.members;
         let span = self.end_span(span);
-        Ok(self.ast.ts_enum_declaration(span, id, members, modifiers))
+
+        for modifier in modifiers.iter() {
+            if !matches!(modifier.kind, ModifierKind::Declare | ModifierKind::Const) {
+                self.error(diagnostics::modifiers_cannot_appear(
+                    modifier.span,
+                    modifier.kind.as_str(),
+                ));
+            }
+        }
+
+        Ok(self.ast.ts_enum_declaration(
+            span,
+            id,
+            members,
+            modifiers.is_contains_const(),
+            modifiers.is_contains_declare(),
+        ))
     }
 
     pub(crate) fn parse_ts_enum_member(&mut self) -> Result<TSEnumMember<'a>> {
@@ -289,7 +306,7 @@ impl<'a> ParserImpl<'a> {
                     .map(Declaration::TSModuleDeclaration)
             }
             Kind::Type => self.parse_ts_type_alias_declaration(start_span, modifiers),
-            Kind::Enum => self.parse_ts_enum_declaration(start_span, modifiers),
+            Kind::Enum => self.parse_ts_enum_declaration(start_span, &modifiers),
             Kind::Interface if self.is_at_interface_declaration() => {
                 self.parse_ts_interface_declaration(start_span, modifiers)
             }

crates/oxc_semantic/src/binder.rs

@@ -320,7 +320,7 @@ impl<'a> Binder for TSInterfaceDeclaration<'a> {
 
 impl<'a> Binder for TSEnumDeclaration<'a> {
     fn bind(&self, builder: &mut SemanticBuilder) {
-        let is_const = self.modifiers.contains(ModifierKind::Const);
+        let is_const = self.r#const;
         let includes = if is_const { SymbolFlags::ConstEnum } else { SymbolFlags::RegularEnum };
         let excludes = if is_const {
             SymbolFlags::ConstEnumExcludes