Fix TypeScript Enum self-references

packages/babel-plugin-transform-typescript/src/enum.ts

@@ -1,7 +1,7 @@
-import assert from "assert";
 import { template } from "@babel/core";
-import type * as t from "@babel/types";
 import type { NodePath } from "@babel/traverse";
+import * as t from "@babel/types";
+import assert from "assert";
 
 export default function transpileEnum(path, t) {
   const { node } = path;
@@ -100,6 +100,28 @@ function enumFill(path, t, id) {
  */
 type PreviousEnumMembers = Map<string, number | string>;
 
+type EnumSelfReferenceVisitorState = {
+  seen: PreviousEnumMembers;
+  path: NodePath<t.TSEnumDeclaration>;
+};
+
+function ReferencedIdentifier(
+  expr: NodePath<t.Identifier>,
+  state: EnumSelfReferenceVisitorState,
+) {
+  const { seen, path } = state;
+  if (expr.isIdentifier() && seen.has(expr.node.name)) {
+    expr.replaceWith(
+      t.memberExpression(t.cloneNode(path.node.id), t.cloneNode(expr.node)),
+    );
+    expr.skip();
+  }
+}
+
+const enumSelfReferenceVisitor = {
+  ReferencedIdentifier,
+};
+
 export function translateEnumValues(
   path: NodePath<t.TSEnumDeclaration>,
   t: typeof import("@babel/types"),
@@ -109,7 +131,8 @@ export function translateEnumValues(
   let constValue: number | string | undefined = -1;
   let lastName: string;
 
-  return path.node.members.map(member => {
+  return path.get("members").map(memberPath => {
+    const member = memberPath.node;
     const name = t.isIdentifier(member.id) ? member.id.name : member.id.value;
     const initializer = member.initializer;
     let value: t.Expression;
@@ -124,7 +147,19 @@ export function translateEnumValues(
           value = t.stringLiteral(constValue);
         }
       } else {
-        value = initializer;
+        const initializerPath = memberPath.get("initializer");
+
+        if (initializerPath.isReferencedIdentifier()) {
+          ReferencedIdentifier(initializerPath, {
+            seen,
+            path,
+          });
+        } else {
+          initializerPath.traverse(enumSelfReferenceVisitor, { seen, path });
+        }
+
+        value = initializerPath.node;
+        seen.set(name, undefined);
       }
     } else if (typeof constValue === "number") {
       constValue += 1;
@@ -140,6 +175,7 @@ export function translateEnumValues(
         true,
       );
       value = t.binaryExpression("+", t.numericLiteral(1), lastRef);
+      seen.set(name, undefined);
     }
 
     lastName = name;

packages/babel-plugin-transform-typescript/test/fixtures/enum/mix-references/input.ts

@@ -0,0 +1,21 @@
+var x = 10;
+
+enum Foo {
+    a = 10,
+    b = a,
+    c = b + x,
+}
+
+enum Bar {
+    D = Foo.a,
+    E = D,
+    F = Math.E,
+    G = E + Foo.c,
+}
+
+enum Baz {
+    a = 0,
+    b = 1,
+    // @ts-ignore
+    x = a.toString(),
+}

packages/babel-plugin-transform-typescript/test/fixtures/enum/mix-references/output.js

@@ -0,0 +1,25 @@
+var x = 10;
+var Foo;
+
+(function (Foo) {
+  Foo[Foo["a"] = 10] = "a";
+  Foo[Foo["b"] = 10] = "b";
+  Foo[Foo["c"] = Foo.b + x] = "c";
+})(Foo || (Foo = {}));
+
+var Bar;
+
+(function (Bar) {
+  Bar[Bar["D"] = Foo.a] = "D";
+  Bar[Bar["E"] = Bar.D] = "E";
+  Bar[Bar["F"] = Math.E] = "F";
+  Bar[Bar["G"] = Bar.E + Foo.c] = "G";
+})(Bar || (Bar = {}));
+
+var Baz;
+
+(function (Baz) {
+  Baz[Baz["a"] = 0] = "a";
+  Baz[Baz["b"] = 1] = "b";
+  Baz[Baz["x"] = Baz.a.toString()] = "x";
+})(Baz || (Baz = {}));