fix(es/parser): Support literal computed property names in enums (#11163)

**Related issue:**

- Closes #11160

Author: magic-akari

.changeset/stale-moons-itch.md

@@ -0,0 +1,6 @@
+---
+swc_core: patch
+swc_ecma_lexer: patch
+---
+
+fix(es/parser): Support literal computed property names in enums

crates/swc/tests/fixture/issues-10xxx/11160/input/.swcrc

@@ -0,0 +1,19 @@
+{
+  "jsc": {
+    "parser": {
+      "syntax": "typescript",
+      "tsx": false
+    },
+    "target": "es5",
+    "loose": false,
+    "minify": {
+      "compress": false,
+      "mangle": false
+    }
+  },
+  "module": {
+    "type": "es6"
+  },
+  "minify": false,
+  "isModule": true
+}

crates/swc/tests/fixture/issues-10xxx/11160/input/index.ts

@@ -0,0 +1,15 @@
+enum CHAR {
+  ["\t"] = 0x09,
+  ["\n"] = 0x0A,
+  ["\v"] = 0x0B,
+  ["\f"] = 0x0C,
+  ["\r"] = 0x0D,
+  [" "] = 0x20,
+
+  ["-"] = 0x2D,
+  ["["] = 0x5B
+}
+
+const c = "\n"
+
+console.log(c.charCodeAt(0) === CHAR["\n"]);

crates/swc/tests/fixture/issues-10xxx/11160/input/test.ts

@@ -0,0 +1,10 @@
+enum CHAR {
+    foo = 1,        // ✅ Regular enum member
+
+    '\t' = 0x09,    // ✅ String literal
+    "\n" = 0x0A,    // ✅ String literal
+
+    ['\v'] = 0x0B,  // ✅ String literal within brackets
+    ["\f"] = 0x0C,  // ✅ String literal within brackets
+    [`\r`] = 0x0D,  // ✅ Template literal (no substitution) within brackets
+}

crates/swc/tests/fixture/issues-10xxx/11160/output/index.ts

@@ -0,0 +1,13 @@
+var CHAR = /*#__PURE__*/ function(CHAR) {
+    CHAR[CHAR["	"] = 9] = "	";
+    CHAR[CHAR["\n"] = 10] = "\n";
+    CHAR[CHAR["\v"] = 11] = "\v";
+    CHAR[CHAR["\f"] = 12] = "\f";
+    CHAR[CHAR["\r"] = 13] = "\r";
+    CHAR[CHAR[" "] = 32] = " ";
+    CHAR[CHAR["-"] = 45] = "-";
+    CHAR[CHAR["["] = 91] = "[";
+    return CHAR;
+}(CHAR || {});
+var c = "\n";
+console.log(c.charCodeAt(0) === 10);

crates/swc/tests/fixture/issues-10xxx/11160/output/test.ts

@@ -0,0 +1,9 @@
+var CHAR = /*#__PURE__*/ function(CHAR) {
+    CHAR[CHAR["foo"] = 1] = "foo";
+    CHAR[CHAR["	"] = 9] = "	";
+    CHAR[CHAR["\n"] = 10] = "\n";
+    CHAR[CHAR["\v"] = 11] = "\v";
+    CHAR[CHAR["\f"] = 12] = "\f";
+    CHAR[CHAR["\r"] = 13] = "\r";
+    return CHAR;
+}(CHAR || {});

crates/swc_ecma_lexer/src/common/parser/typescript.rs

@@ -1,4 +1,4 @@
-use std::fmt::Write;
+use std::{fmt::Write, mem};
 
 use either::Either;
 use swc_atoms::{atom, Atom};
@@ -946,8 +946,10 @@ fn parse_ts_enum_member<'a, P: Parser<'a>>(p: &mut P) -> PResult<TsEnumMember> {
     debug_assert!(p.input().syntax().typescript());
 
     let start = p.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 = p.input().cur();
     let id = if cur.is_str() {
         TsEnumMemberId::Str(parse_str_lit(p))
@@ -971,10 +973,35 @@ fn parse_ts_enum_member<'a, P: Parser<'a>>(p: &mut P) -> PResult<TsEnumMember> {
         })
     } else if cur.is_lbracket() {
         p.assert_and_bump(&P::Token::LBRACKET);
-        let _ = p.parse_expr()?;
-        p.emit_err(p.span(start), SyntaxError::TS1164);
+        let expr = p.parse_expr()?;
         p.assert_and_bump(&P::Token::RBRACKET);
-        TsEnumMemberId::Ident(Ident::new_no_ctxt(atom!(""), p.span(start)))
+        let bracket_span = p.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
+                p.emit_err(bracket_span, SyntaxError::TS1164);
+                TsEnumMemberId::Ident(Ident::new_no_ctxt(atom!(""), bracket_span))
+            }
+        }
     } else if cur.is_error() {
         let err = p.input_mut().expect_error_token_and_bump();
         return Err(err);

crates/swc_ecma_parser/tests/typescript/issue-11160/input.ts

@@ -0,0 +1,10 @@
+export enum CHAR {
+    foo = 1,        // ✅ Regular enum member
+
+    '\t' = 0x09,    // ✅ String literal
+    "\n" = 0x0A,    // ✅ String literal
+
+    ['\v'] = 0x0B,  // ✅ String literal within brackets
+    ["\f"] = 0x0C,  // ✅ String literal within brackets
+    [`\r`] = 0x0D,  // ✅ Template literal (no substitution) within brackets
+}

crates/swc_ecma_parser/tests/typescript/issue-11160/input.ts.json

@@ -0,0 +1,189 @@
+{
+  "type": "Module",
+  "span": {
+    "start": 1,
+    "end": 348
+  },
+  "body": [
+    {
+      "type": "ExportDeclaration",
+      "span": {
+        "start": 1,
+        "end": 348
+      },
+      "declaration": {
+        "type": "TsEnumDeclaration",
+        "span": {
+          "start": 8,
+          "end": 348
+        },
+        "declare": false,
+        "isConst": false,
+        "id": {
+          "type": "Identifier",
+          "span": {
+            "start": 13,
+            "end": 17
+          },
+          "ctxt": 0,
+          "value": "CHAR",
+          "optional": false
+        },
+        "members": [
+          {
+            "type": "TsEnumMember",
+            "span": {
+              "start": 24,
+              "end": 31
+            },
+            "id": {
+              "type": "Identifier",
+              "span": {
+                "start": 24,
+                "end": 27
+              },
+              "ctxt": 0,
+              "value": "foo",
+              "optional": false
+            },
+            "init": {
+              "type": "NumericLiteral",
+              "span": {
+                "start": 30,
+                "end": 31
+              },
+              "value": 1.0,
+              "raw": "1"
+            }
+          },
+          {
+            "type": "TsEnumMember",
+            "span": {
+              "start": 72,
+              "end": 83
+            },
+            "id": {
+              "type": "StringLiteral",
+              "span": {
+                "start": 72,
+                "end": 76
+              },
+              "value": "\t",
+              "raw": "'\\t'"
+            },
+            "init": {
+              "type": "NumericLiteral",
+              "span": {
+                "start": 79,
+                "end": 83
+              },
+              "value": 9.0,
+              "raw": "0x09"
+            }
+          },
+          {
+            "type": "TsEnumMember",
+            "span": {
+              "start": 114,
+              "end": 125
+            },
+            "id": {
+              "type": "StringLiteral",
+              "span": {
+                "start": 114,
+                "end": 118
+              },
+              "value": "\n",
+              "raw": "\"\\n\""
+            },
+            "init": {
+              "type": "NumericLiteral",
+              "span": {
+                "start": 121,
+                "end": 125
+              },
+              "value": 10.0,
+              "raw": "0x0A"
+            }
+          },
+          {
+            "type": "TsEnumMember",
+            "span": {
+              "start": 157,
+              "end": 170
+            },
+            "id": {
+              "type": "StringLiteral",
+              "span": {
+                "start": 158,
+                "end": 162
+              },
+              "value": "\u000b",
+              "raw": "'\\v'"
+            },
+            "init": {
+              "type": "NumericLiteral",
+              "span": {
+                "start": 166,
+                "end": 170
+              },
+              "value": 11.0,
+              "raw": "0x0B"
+            }
+          },
+          {
+            "type": "TsEnumMember",
+            "span": {
+              "start": 215,
+              "end": 228
+            },
+            "id": {
+              "type": "StringLiteral",
+              "span": {
+                "start": 216,
+                "end": 220
+              },
+              "value": "\f",
+              "raw": "\"\\f\""
+            },
+            "init": {
+              "type": "NumericLiteral",
+              "span": {
+                "start": 224,
+                "end": 228
+              },
+              "value": 12.0,
+              "raw": "0x0C"
+            }
+          },
+          {
+            "type": "TsEnumMember",
+            "span": {
+              "start": 273,
+              "end": 286
+            },
+            "id": {
+              "type": "StringLiteral",
+              "span": {
+                "start": 275,
+                "end": 277
+              },
+              "value": "\r",
+              "raw": null
+            },
+            "init": {
+              "type": "NumericLiteral",
+              "span": {
+                "start": 282,
+                "end": 286
+              },
+              "value": 13.0,
+              "raw": "0x0D"
+            }
+          }
+        ]
+      }
+    }
+  ],
+  "interpreter": null
+}