Rebase #11163

Author: CPunisher

crates/swc_ecma_parser/src/parser/typescript.rs

@@ -1,4 +1,4 @@
-use std::fmt::Write;
+use std::{fmt::Write, mem};
 
 use either::Either;
 use swc_atoms::{atom, Atom, Wtf8Atom};
@@ -954,8 +954,10 @@ impl<I: Tokens> Parser<I> {
         debug_assert!(self.input().syntax().typescript());
 
         let start = self.cur_pos();
-        // Computed property names are grammar errors in an enum, so accept just string
-        // literal or identifier.
+        // TypeScript allows computed property names with literal expressions in enums.
+        // Non-literal computed properties (like ["a" + "b"]) are rejected.
+        // We normalize literal computed properties (["\t"] → "\t") to keep AST simple.
+        // See https://github.com/swc-project/swc/issues/11160
         let cur = self.input().cur();
         let id = if cur == Token::Str {
             TsEnumMemberId::Str(self.parse_str_lit())
@@ -979,10 +981,35 @@ impl<I: Tokens> Parser<I> {
             })
         } else if cur == Token::LBracket {
             self.assert_and_bump(Token::LBracket);
-            let _ = self.parse_expr()?;
-            self.emit_err(self.span(start), SyntaxError::TS1164);
+            let expr = self.parse_expr()?;
             self.assert_and_bump(Token::RBracket);
-            TsEnumMemberId::Ident(Ident::new_no_ctxt(atom!(""), self.span(start)))
+            let bracket_span = self.span(start);
+
+            match *expr {
+                Expr::Lit(Lit::Str(str_lit)) => {
+                    // String literal: ["\t"] → "\t"
+                    TsEnumMemberId::Str(str_lit)
+                }
+                Expr::Tpl(mut tpl) if tpl.exprs.is_empty() => {
+                    // Template literal without substitution: [`hello`] → "hello"
+
+                    let tpl = mem::take(tpl.quasis.first_mut().unwrap());
+
+                    let span = tpl.span;
+                    let value = tpl.cooked.unwrap();
+
+                    TsEnumMemberId::Str(Str {
+                        span,
+                        value,
+                        raw: None,
+                    })
+                }
+                _ => {
+                    // Non-literal expression: report error
+                    self.emit_err(bracket_span, SyntaxError::TS1164);
+                    TsEnumMemberId::Ident(Ident::new_no_ctxt(atom!(""), bracket_span))
+                }
+            }
         } else if cur == Token::Error {
             let err = self.input_mut().expect_error_token_and_bump();
             return Err(err);