fix(es/typescript): Handle TypeScript expressions in enum transformation

crates/swc/tests/fixture/issues-11xxx/11761/input/.swcrc

@@ -0,0 +1,13 @@
+{
+  "jsc": {
+    "parser": {
+      "syntax": "typescript",
+      "tsx": false
+    },
+    "target": "es2024"
+  },
+  "module": {
+    "type": "es6"
+  },
+  "isModule": true
+}

crates/swc/tests/fixture/issues-11xxx/11761/input/a.ts

@@ -0,0 +1,6 @@
+export enum RefType {
+    property = "11" as any,
+    event = "22" as any,
+}
+
+console.log(RefType.property, RefType.event);

crates/swc/tests/fixture/issues-11xxx/11761/input/b.ts

@@ -0,0 +1,4 @@
+enum E {
+    A = ((B: number) => B)(2),
+    B = 1,
+}

crates/swc/tests/fixture/issues-11xxx/11761/input/c.ts

@@ -0,0 +1,10 @@
+enum E {
+    A,
+    B,
+    C,
+    D = ((C) => {
+        console.log(A, B, C, F);
+        return 2;
+    })(),
+    F = "F",
+}

crates/swc/tests/fixture/issues-11xxx/11761/output/a.ts

@@ -0,0 +1,6 @@
+export var RefType = /*#__PURE__*/ function(RefType) {
+    RefType["property"] = "11";
+    RefType["event"] = "22";
+    return RefType;
+}({});
+console.log("11", "22");

crates/swc/tests/fixture/issues-11xxx/11761/output/b.ts

@@ -0,0 +1,5 @@
+var E = function(E) {
+    E[E["A"] = ((B)=>B)(2)] = "A";
+    E[E["B"] = 1] = "B";
+    return E;
+}(E || {});

crates/swc/tests/fixture/issues-11xxx/11761/output/c.ts

@@ -0,0 +1,11 @@
+var E = function(E) {
+    E[E["A"] = 0] = "A";
+    E[E["B"] = 1] = "B";
+    E[E["C"] = 2] = "C";
+    E[E["D"] = ((C)=>{
+        console.log(E.A, E.B, C, E.F);
+        return 2;
+    })()] = "D";
+    E["F"] = "F";
+    return E;
+}(E || {});

crates/swc/tests/tsc-references/constEnum2.1.normal.js

@@ -6,7 +6,7 @@
 var CONST = 9000 % 2;
 var D = function(D) {
     D[D["e"] = 199 * Math.floor(Math.random() * 1000)] = "e";
-    D[D["f"] = 10 - 100 * Math.floor(Math.random() % 8)] = "f";
+    D[D["f"] = D.d - 100 * Math.floor(Math.random() % 8)] = "f";
     D[D["g"] = CONST] = "g";
     return D;
 }(D || {});

crates/swc/tests/tsc-references/constEnum2.2.minified.js

@@ -1,2 +1,2 @@
 //// [constEnum2.ts]
-var D, D1 = ((D = D1 || {})[D.e = 199 * Math.floor(1000 * Math.random())] = "e", D[D.f = 10 - 100 * Math.floor(Math.random() % 8)] = "f", D[D.g = 0] = "g", D);
+var D, D1 = ((D = D1 || {})[D.e = 199 * Math.floor(1000 * Math.random())] = "e", D[D.f = D.d - 100 * Math.floor(Math.random() % 8)] = "f", D[D.g = 0] = "g", D);

crates/swc/tests/tsc-references/enumBasics.1.normal.js

@@ -26,7 +26,7 @@ var E2 = /*#__PURE__*/ function(E2) {
 var E3 = function(E3) {
     E3[E3["X"] = 'foo'.length] = "X";
     E3[E3["Y"] = 7] = "Y";
-    E3[E3["Z"] = +"foo"] = "Z";
+    E3[E3["Z"] = +'foo'] = "Z";
     return E3;
 }(E3 || {});
 // Enum with constant members followed by computed members

crates/swc_ecma_transforms_base/src/resolver/mod.rs

@@ -1258,15 +1258,20 @@ impl VisitMut for Resolver<'_> {
         self.modify(&mut decl.id, DeclKind::Lexical);
 
         self.with_child(ScopeKind::Block, |child| {
-            // add the enum member names as declared symbols for this scope
-            // Ex. `enum Foo { a, b = a }`
-            let member_names = decl.members.iter().filter_map(|m| match &m.id {
-                TsEnumMemberId::Ident(id) => Some((id.sym.clone(), DeclKind::Lexical)),
-                TsEnumMemberId::Str(_) => None,
-                #[cfg(swc_ast_unknown)]
-                _ => None,
-            });
-            child.current.declared_symbols.extend(member_names);
+            // Intentionally do not predeclare enum members in the resolver.
+            // Enum initializers may reference other members, including quoted names whose
+            // text is a valid identifier:
+            //
+            // ```TypeScript
+            //   enum E {
+            //       A = "A",
+            //       "B" = "B",
+            //       C = (() => { console.log(A, B); })(),
+            //   }
+            // ```
+            //
+            // We keep those references unresolved here so the TypeScript enum transform
+            // can rewrite them using semantic.enum_record.
 
             decl.members.visit_mut_with(child);
         });

crates/swc_ecma_transforms_typescript/src/transform.rs

@@ -1052,6 +1052,13 @@ impl Transform {
             && !is_export
             && !self.semantic.exported_binding.contains_key(&id.to_id());
 
+        let member_names = self
+            .semantic
+            .enum_record
+            .keys()
+            .map(|k| k.member_name.clone())
+            .collect();
+
         let member_list: Vec<_> = members
             .into_iter()
             .map(|m| {
@@ -1063,7 +1070,18 @@ impl Transform {
                     member_name: name.clone(),
                 };
 
-                let value = self.semantic.enum_record.get(&key).unwrap().clone();
+                let mut value = self.semantic.enum_record.get(&key).unwrap().clone();
+
+                if let TsEnumRecordValue::Opaque(expr) = &mut value {
+                    *expr = m.init.unwrap();
+                    expr.visit_mut_with(&mut RefRewriter {
+                        query: EnumMemberRefQuery {
+                            enum_id: &id.to_id(),
+                            member_names: &member_names,
+                            unresolved_ctxt: self.unresolved_ctxt,
+                        },
+                    });
+                }
 
                 EnumMemberItem { span, name, value }
             })
@@ -1817,6 +1835,46 @@ impl QueryRef for ExportQuery {
     }
 }
 
+struct EnumMemberRefQuery<'a> {
+    enum_id: &'a Id,
+    member_names: &'a FxHashSet<Atom>,
+    unresolved_ctxt: SyntaxContext,
+}
+
+impl QueryRef for EnumMemberRefQuery<'_> {
+    fn query_ref(&self, ident: &Ident) -> Option<Box<Expr>> {
+        if ident.ctxt == self.unresolved_ctxt && self.member_names.contains(&ident.sym) {
+            Some(
+                self.enum_id
+                    .clone()
+                    .make_member(ident.clone().into())
+                    .into(),
+            )
+        } else {
+            None
+        }
+    }
+
+    fn query_lhs(&self, ident: &Ident) -> Option<Box<Expr>> {
+        self.query_ref(ident)
+    }
+
+    fn query_jsx(&self, ident: &Ident) -> Option<JSXElementName> {
+        if ident.ctxt == self.unresolved_ctxt && self.member_names.contains(&ident.sym) {
+            Some(
+                JSXMemberExpr {
+                    span: DUMMY_SP,
+                    obj: JSXObject::Ident(self.enum_id.clone().into()),
+                    prop: ident.clone().into(),
+                }
+                .into(),
+            )
+        } else {
+            None
+        }
+    }
+}
+
 struct EnumMemberItem {
     span: Span,
     name: Atom,

crates/swc_ecma_transforms_typescript/src/ts_enum.rs

@@ -6,7 +6,6 @@ use swc_ecma_utils::{
     number::{JsNumber, ToJsString},
     ExprFactory,
 };
-use swc_ecma_visit::{noop_visit_mut_type, VisitMut, VisitMutWith};
 
 #[inline]
 fn atom_from_wtf8_atom(value: &Wtf8Atom) -> Atom {
@@ -111,50 +110,57 @@ pub(crate) struct EnumValueComputer<'a> {
 
 /// https://github.com/microsoft/TypeScript/pull/50528
 impl EnumValueComputer<'_> {
-    pub fn compute(&mut self, expr: Box<Expr>) -> TsEnumRecordValue {
-        let mut expr = self.compute_rec(expr);
-        if let TsEnumRecordValue::Opaque(expr) = &mut expr {
-            expr.visit_mut_with(self);
-        }
-        expr
+    pub fn compute(&self, expr: Box<Expr>) -> TsEnumRecordValue {
+        self.compute_rec(expr)
     }
 
     fn compute_rec(&self, expr: Box<Expr>) -> TsEnumRecordValue {
         match *expr {
             Expr::Lit(Lit::Str(s)) => TsEnumRecordValue::String(atom_from_wtf8_atom(&s.value)),
             Expr::Lit(Lit::Num(n)) => TsEnumRecordValue::Number(n.value.into()),
-            Expr::Ident(Ident { ctxt, sym, .. })
-                if &*sym == "NaN" && ctxt == self.unresolved_ctxt =>
+            Expr::Ident(Ident { ctxt, ref sym, .. })
+                if *sym == "NaN" && ctxt == self.unresolved_ctxt =>
             {
                 TsEnumRecordValue::Number(f64::NAN.into())
             }
-            Expr::Ident(Ident { ctxt, sym, .. })
-                if &*sym == "Infinity" && ctxt == self.unresolved_ctxt =>
+            Expr::Ident(Ident { ctxt, ref sym, .. })
+                if *sym == "Infinity" && ctxt == self.unresolved_ctxt =>
             {
                 TsEnumRecordValue::Number(f64::INFINITY.into())
             }
-            Expr::Ident(ref ident) => self
-                .record
-                .get(&TsEnumRecordKey {
-                    enum_id: self.enum_id.clone(),
-                    member_name: ident.sym.clone(),
-                })
-                .cloned()
-                .map(|value| match value {
-                    TsEnumRecordValue::String(..) | TsEnumRecordValue::Number(..) => value,
-                    _ => TsEnumRecordValue::Opaque(
-                        self.enum_id
-                            .clone()
-                            .make_member(ident.clone().into())
-                            .into(),
-                    ),
-                })
-                .unwrap_or_else(|| TsEnumRecordValue::Opaque(expr)),
+            Expr::Ident(ref ident @ Ident { ctxt, ref sym, .. })
+                if ctxt == self.unresolved_ctxt =>
+            {
+                self.record
+                    .get(&TsEnumRecordKey {
+                        enum_id: self.enum_id.clone(),
+                        member_name: sym.clone(),
+                    })
+                    .cloned()
+                    .map(|value| match value {
+                        TsEnumRecordValue::String(..) | TsEnumRecordValue::Number(..) => value,
+                        _ => TsEnumRecordValue::Opaque(
+                            self.enum_id
+                                .clone()
+                                .make_member(ident.clone().into())
+                                .into(),
+                        ),
+                    })
+                    .unwrap_or_else(|| TsEnumRecordValue::Opaque(expr))
+            }
             Expr::Paren(e) => self.compute_rec(e.expr),
             Expr::Unary(e) => self.compute_unary(e),
             Expr::Bin(e) => self.compute_bin(e),
             Expr::Member(e) => self.compute_member(e),
             Expr::Tpl(e) => self.compute_tpl(e),
+            // Handle TypeScript type expressions by stripping them
+            // and computing the inner expression
+            Expr::TsAs(TsAsExpr { expr, .. })
+            | Expr::TsNonNull(TsNonNullExpr { expr, .. })
+            | Expr::TsTypeAssertion(TsTypeAssertion { expr, .. })
+            | Expr::TsConstAssertion(TsConstAssertion { expr, .. })
+            | Expr::TsInstantiation(TsInstantiation { expr, .. })
+            | Expr::TsSatisfies(TsSatisfiesExpr { expr, .. }) => self.compute_rec(expr),
             _ => TsEnumRecordValue::Opaque(expr),
         }
     }
@@ -317,24 +323,3 @@ impl EnumValueComputer<'_> {
         TsEnumRecordValue::String(string.into())
     }
 }
-
-impl VisitMut for EnumValueComputer<'_> {
-    noop_visit_mut_type!();
-
-    fn visit_mut_expr(&mut self, expr: &mut Expr) {
-        expr.visit_mut_children_with(self);
-
-        let Expr::Ident(ident) = expr else { return };
-
-        if self.record.contains_key(&TsEnumRecordKey {
-            enum_id: self.enum_id.clone(),
-            member_name: ident.sym.clone(),
-        }) {
-            *expr = self
-                .enum_id
-                .clone()
-                .make_member(ident.clone().into())
-                .into();
-        }
-    }
-}

crates/swc_ecma_transforms_typescript/tests/__swc_snapshots__/tests/strip.rs/issue_6219.js

@@ -1,4 +1,4 @@
 var A = function(A) {
-    A[A["a"] = a] = "a";
+    A[A["a"] = A.a] = "a";
     return A;
 }(A || {});

crates/swc_ecma_transforms_typescript/tests/__swc_snapshots__/tests/strip.rs/ts_enum_with_nested_class.js

@@ -0,0 +1,8 @@
+var Foo = function(Foo) {
+    Foo[Foo["a"] = (class {
+        constructor(b){
+            this.b = b;
+        }
+    }, 0)] = "a";
+    return Foo;
+}(Foo || {});

crates/swc_ecma_transforms_typescript/tests/__swc_snapshots__/tests/strip.rs/ts_enum_with_nested_enum.js

@@ -0,0 +1,11 @@
+var Foo = function(Foo) {
+    Foo[Foo["a"] = (()=>{
+        let Bar = /*#__PURE__*/ function(Bar) {
+            Bar["a"] = "a";
+            Bar["b"] = "b";
+            return Bar;
+        }({});
+        return 0;
+    })()] = "a";
+    return Foo;
+}(Foo || {});

crates/swc_ecma_transforms_typescript/tests/__swc_snapshots__/tests/strip.rs/ts_enum_with_opaque_expr.js

@@ -0,0 +1,4 @@
+var Foo = function(Foo) {
+    Foo[Foo["a"] = foo('x')] = "a";
+    return Foo;
+}(Foo || {});

crates/swc_ecma_transforms_typescript/tests/__swc_snapshots__/tests/strip.rs/ts_enum_with_type_assertion.js

@@ -0,0 +1,5 @@
+var RefType = /*#__PURE__*/ function(RefType) {
+    RefType["property"] = "11";
+    RefType["event"] = "22";
+    return RefType;
+}(RefType || {});

crates/swc_ecma_transforms_typescript/tests/fixture/issue-3001/2/output.js

@@ -2,7 +2,7 @@ var x = 10;
 var Foo = function(Foo) {
     Foo[Foo["a"] = 10] = "a";
     Foo[Foo["b"] = 10] = "b";
-    Foo[Foo["c"] = 10 + x] = "c";
+    Foo[Foo["c"] = Foo.b + x] = "c";
     Foo[Foo["d"] = Foo.c] = "d";
     return Foo;
 }(Foo || {});