refactor(ast): Add TSEnumMemberName variant to replace computed field (oxc-project#10346)

Fixes oxc-project#10332

---------

Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Co-authored-by: overlookmotel <[email protected]>

Author: 3 people

crates/oxc_ast/src/ast/ts.rs

@@ -119,21 +119,38 @@ pub struct TSEnumBody<'a> {
 #[ast(visit)]
 #[derive(Debug)]
 #[generate_derive(CloneIn, Dummy, TakeIn, GetSpan, GetSpanMut, ContentEq, ESTree)]
+#[estree(
+    add_fields(computed = TSEnumMemberComputed),
+    field_order(span, id, computed, initializer),
+)]
 pub struct TSEnumMember<'a> {
     pub span: Span,
     pub id: TSEnumMemberName<'a>,
-    pub computed: bool,
     pub initializer: Option<Expression<'a>>,
 }
 
 /// TS Enum Member Name
+///
+/// ## Example
+/// ```ts
+/// enum ValidEnum {
+///   identifier,
+///   'string',
+///   ['computed-string'],
+///   [`computed-template`],
+///   // These are invalid syntax
+///   // `template`,
+///   // [computedIdentifier],
+/// }
+/// ```
 #[ast(visit)]
 #[derive(Debug)]
 #[generate_derive(CloneIn, Dummy, TakeIn, GetSpan, GetSpanMut, GetAddress, ContentEq, ESTree)]
 pub enum TSEnumMemberName<'a> {
     Identifier(Box<'a, IdentifierName<'a>>) = 0,
     String(Box<'a, StringLiteral<'a>>) = 1,
-    TemplateString(Box<'a, TemplateLiteral<'a>>) = 2,
+    ComputedString(Box<'a, StringLiteral<'a>>) = 2,
+    ComputedTemplateString(Box<'a, TemplateLiteral<'a>>) = 3,
 }
 
 /// TypeScript Type Annotation

crates/oxc_ast/src/ast_impl/ts.rs

@@ -17,8 +17,8 @@ impl<'a> TSEnumMemberName<'a> {
     pub fn static_name(&self) -> Atom<'a> {
         match self {
             Self::Identifier(ident) => ident.name,
-            Self::String(lit) => lit.value,
-            Self::TemplateString(template) => template
+            Self::String(lit) | Self::ComputedString(lit) => lit.value,
+            Self::ComputedTemplateString(template) => template
                 .quasi()
                 .expect("`TSEnumMemberName::TemplateString` should have no substitution and at least one quasi"),
         }

crates/oxc_ast/src/generated/assert_layouts.rs

@@ -925,12 +925,11 @@ const _: () = {
     assert!(offset_of!(TSEnumBody, span) == 0);
     assert!(offset_of!(TSEnumBody, members) == 8);
 
-    assert!(size_of::<TSEnumMember>() == 48);
+    assert!(size_of::<TSEnumMember>() == 40);
     assert!(align_of::<TSEnumMember>() == 8);
     assert!(offset_of!(TSEnumMember, span) == 0);
     assert!(offset_of!(TSEnumMember, id) == 8);
-    assert!(offset_of!(TSEnumMember, computed) == 24);
-    assert!(offset_of!(TSEnumMember, initializer) == 32);
+    assert!(offset_of!(TSEnumMember, initializer) == 24);
 
     assert!(size_of::<TSEnumMemberName>() == 16);
     assert!(align_of::<TSEnumMemberName>() == 8);
@@ -2321,12 +2320,11 @@ const _: () = {
     assert!(offset_of!(TSEnumBody, span) == 0);
     assert!(offset_of!(TSEnumBody, members) == 8);
 
-    assert!(size_of::<TSEnumMember>() == 28);
+    assert!(size_of::<TSEnumMember>() == 24);
     assert!(align_of::<TSEnumMember>() == 4);
     assert!(offset_of!(TSEnumMember, span) == 0);
     assert!(offset_of!(TSEnumMember, id) == 8);
-    assert!(offset_of!(TSEnumMember, computed) == 16);
-    assert!(offset_of!(TSEnumMember, initializer) == 20);
+    assert!(offset_of!(TSEnumMember, initializer) == 16);
 
     assert!(size_of::<TSEnumMemberName>() == 8);
     assert!(align_of::<TSEnumMemberName>() == 4);

crates/oxc_ast/src/generated/ast_builder.rs

@@ -9748,17 +9748,15 @@ impl<'a> AstBuilder<'a> {
     /// ## Parameters
     /// * `span`: The [`Span`] covering this node
     /// * `id`
-    /// * `computed`
     /// * `initializer`
     #[inline]
     pub fn ts_enum_member(
         self,
         span: Span,
         id: TSEnumMemberName<'a>,
-        computed: bool,
         initializer: Option<Expression<'a>>,
     ) -> TSEnumMember<'a> {
-        TSEnumMember { span, id, computed, initializer }
+        TSEnumMember { span, id, initializer }
     }
 
     /// Build a [`TSEnumMemberName::Identifier`].
@@ -9825,7 +9823,56 @@ impl<'a> AstBuilder<'a> {
         ))
     }
 
-    /// Build a [`TSEnumMemberName::TemplateString`].
+    /// Build a [`TSEnumMemberName::ComputedString`].
+    ///
+    /// This node contains a [`StringLiteral`] that will be stored in the memory arena.
+    ///
+    /// ## Parameters
+    /// * `span`: Node location in source code
+    /// * `value`: The value of the string.
+    /// * `raw`: The raw string as it appears in source code.
+    #[inline]
+    pub fn ts_enum_member_name_computed_string<A>(
+        self,
+        span: Span,
+        value: A,
+        raw: Option<Atom<'a>>,
+    ) -> TSEnumMemberName<'a>
+    where
+        A: IntoIn<'a, Atom<'a>>,
+    {
+        TSEnumMemberName::ComputedString(self.alloc_string_literal(span, value, raw))
+    }
+
+    /// Build a [`TSEnumMemberName::ComputedString`] with `lone_surrogates`.
+    ///
+    /// This node contains a [`StringLiteral`] that will be stored in the memory arena.
+    ///
+    /// ## Parameters
+    /// * `span`: Node location in source code
+    /// * `value`: The value of the string.
+    /// * `raw`: The raw string as it appears in source code.
+    /// * `lone_surrogates`: The string value contains lone surrogates.
+    #[inline]
+    pub fn ts_enum_member_name_computed_string_with_lone_surrogates<A>(
+        self,
+        span: Span,
+        value: A,
+        raw: Option<Atom<'a>>,
+        lone_surrogates: bool,
+    ) -> TSEnumMemberName<'a>
+    where
+        A: IntoIn<'a, Atom<'a>>,
+    {
+        TSEnumMemberName::ComputedString(self.alloc_string_literal_with_lone_surrogates(
+            span,
+            value,
+            raw,
+            lone_surrogates,
+        ))
+    }
+
+    /// Build a [`TSEnumMemberName::ComputedTemplateString`].
     ///
     /// This node contains a [`TemplateLiteral`] that will be stored in the memory arena.
     ///
@@ -9834,13 +9881,17 @@ impl<'a> AstBuilder<'a> {
     /// * `quasis`
     /// * `expressions`
     #[inline]
-    pub fn ts_enum_member_name_template_string(
+    pub fn ts_enum_member_name_computed_template_string(
         self,
         span: Span,
         quasis: Vec<'a, TemplateElement<'a>>,
         expressions: Vec<'a, Expression<'a>>,
     ) -> TSEnumMemberName<'a> {
-        TSEnumMemberName::TemplateString(self.alloc_template_literal(span, quasis, expressions))
+        TSEnumMemberName::ComputedTemplateString(self.alloc_template_literal(
+            span,
+            quasis,
+            expressions,
+        ))
     }
 
     /// Build a [`TSTypeAnnotation`].

crates/oxc_ast/src/generated/derive_clone_in.rs

@@ -5746,7 +5746,6 @@ impl<'new_alloc> CloneIn<'new_alloc> for TSEnumMember<'_> {
         TSEnumMember {
             span: CloneIn::clone_in(&self.span, allocator),
             id: CloneIn::clone_in(&self.id, allocator),
-            computed: CloneIn::clone_in(&self.computed, allocator),
             initializer: CloneIn::clone_in(&self.initializer, allocator),
         }
     }
@@ -5755,7 +5754,6 @@ impl<'new_alloc> CloneIn<'new_alloc> for TSEnumMember<'_> {
         TSEnumMember {
             span: CloneIn::clone_in_with_semantic_ids(&self.span, allocator),
             id: CloneIn::clone_in_with_semantic_ids(&self.id, allocator),
-            computed: CloneIn::clone_in_with_semantic_ids(&self.computed, allocator),
             initializer: CloneIn::clone_in_with_semantic_ids(&self.initializer, allocator),
         }
     }
@@ -5768,8 +5766,11 @@ impl<'new_alloc> CloneIn<'new_alloc> for TSEnumMemberName<'_> {
         match self {
             Self::Identifier(it) => TSEnumMemberName::Identifier(CloneIn::clone_in(it, allocator)),
             Self::String(it) => TSEnumMemberName::String(CloneIn::clone_in(it, allocator)),
-            Self::TemplateString(it) => {
-                TSEnumMemberName::TemplateString(CloneIn::clone_in(it, allocator))
+            Self::ComputedString(it) => {
+                TSEnumMemberName::ComputedString(CloneIn::clone_in(it, allocator))
+            }
+            Self::ComputedTemplateString(it) => {
+                TSEnumMemberName::ComputedTemplateString(CloneIn::clone_in(it, allocator))
             }
         }
     }
@@ -5782,9 +5783,12 @@ impl<'new_alloc> CloneIn<'new_alloc> for TSEnumMemberName<'_> {
             Self::String(it) => {
                 TSEnumMemberName::String(CloneIn::clone_in_with_semantic_ids(it, allocator))
             }
-            Self::TemplateString(it) => {
-                TSEnumMemberName::TemplateString(CloneIn::clone_in_with_semantic_ids(it, allocator))
+            Self::ComputedString(it) => {
+                TSEnumMemberName::ComputedString(CloneIn::clone_in_with_semantic_ids(it, allocator))
             }
+            Self::ComputedTemplateString(it) => TSEnumMemberName::ComputedTemplateString(
+                CloneIn::clone_in_with_semantic_ids(it, allocator),
+            ),
         }
     }
 }

crates/oxc_ast/src/generated/derive_content_eq.rs

@@ -1745,7 +1745,6 @@ impl ContentEq for TSEnumBody<'_> {
 impl ContentEq for TSEnumMember<'_> {
     fn content_eq(&self, other: &Self) -> bool {
         ContentEq::content_eq(&self.id, &other.id)
-            && ContentEq::content_eq(&self.computed, &other.computed)
             && ContentEq::content_eq(&self.initializer, &other.initializer)
     }
 }
@@ -1755,7 +1754,8 @@ impl ContentEq for TSEnumMemberName<'_> {
         match (self, other) {
             (Self::Identifier(a), Self::Identifier(b)) => a.content_eq(b),
             (Self::String(a), Self::String(b)) => a.content_eq(b),
-            (Self::TemplateString(a), Self::TemplateString(b)) => a.content_eq(b),
+            (Self::ComputedString(a), Self::ComputedString(b)) => a.content_eq(b),
+            (Self::ComputedTemplateString(a), Self::ComputedTemplateString(b)) => a.content_eq(b),
             _ => false,
         }
     }

crates/oxc_ast/src/generated/derive_dummy.rs

@@ -1922,7 +1922,6 @@ impl<'a> Dummy<'a> for TSEnumMember<'a> {
         Self {
             span: Dummy::dummy(allocator),
             id: Dummy::dummy(allocator),
-            computed: Dummy::dummy(allocator),
             initializer: Dummy::dummy(allocator),
         }
     }

crates/oxc_ast/src/generated/derive_estree.rs

@@ -2310,7 +2310,7 @@ impl ESTree for TSEnumMember<'_> {
         state.serialize_field("start", &self.span.start);
         state.serialize_field("end", &self.span.end);
         state.serialize_field("id", &self.id);
-        state.serialize_field("computed", &self.computed);
+        state.serialize_field("computed", &crate::serialize::TSEnumMemberComputed(self));
         state.serialize_field("initializer", &self.initializer);
         state.end();
     }
@@ -2321,7 +2321,8 @@ impl ESTree for TSEnumMemberName<'_> {
         match self {
             Self::Identifier(it) => it.serialize(serializer),
             Self::String(it) => it.serialize(serializer),
-            Self::TemplateString(it) => it.serialize(serializer),
+            Self::ComputedString(it) => it.serialize(serializer),
+            Self::ComputedTemplateString(it) => it.serialize(serializer),
         }
     }
 }

crates/oxc_ast/src/generated/derive_get_address.rs

@@ -605,7 +605,8 @@ impl GetAddress for TSEnumMemberName<'_> {
         match self {
             Self::Identifier(it) => GetAddress::address(it),
             Self::String(it) => GetAddress::address(it),
-            Self::TemplateString(it) => GetAddress::address(it),
+            Self::ComputedString(it) => GetAddress::address(it),
+            Self::ComputedTemplateString(it) => GetAddress::address(it),
         }
     }
 }

crates/oxc_ast/src/generated/derive_get_span.rs

@@ -1507,7 +1507,8 @@ impl GetSpan for TSEnumMemberName<'_> {
         match self {
             Self::Identifier(it) => GetSpan::span(&**it),
             Self::String(it) => GetSpan::span(&**it),
-            Self::TemplateString(it) => GetSpan::span(&**it),
+            Self::ComputedString(it) => GetSpan::span(&**it),
+            Self::ComputedTemplateString(it) => GetSpan::span(&**it),
         }
     }
 }