fix(transformer): keep enum IIFE when a non-inlinable value reference remains

The optimize pass dropped the enum declaration whenever the members were
all evaluable — regardless of whether some non-inlinable value reference
still named the enum. The result referenced a binding that no longer
existed:

    const enum Phase { one = 'one' }
    export default Phase;
    // -> export default Phase;  // ReferenceError at runtime

    enum Direction { Up }
    Direction.Up.toString();
    // -> Direction.Up.toString();  // ReferenceError at runtime

Decide based on the remaining resolved references: drop only when none
of them is a value reference (`Read`/`Write`). Type references
(`as E`, `: E`) are kept here and stripped later by `annotations.rs`,
so they don't block removal. `typeof E` in JS expression position is
`Read` and correctly keeps the IIFE; `typeof E` in TS type position
is `ValueAsType` (not in `Value`) and doesn't.

This unifies the rule for regular and const enums — the previous
asymmetry (const always dropped, regular dropped only when no refs at
all) had no principled basis.

Diverges from Babel's `optimize-const-enums/local` and `/merged`
fixtures, which expect the declaration dropped. tsc under
`--isolatedModules` keeps the IIFE; oxc now matches that.

Refs vitejs/vite#22452 (comment)

Author: Dunqing

crates/oxc_transformer/src/typescript/enum.rs

@@ -432,12 +432,21 @@ impl<'a> TypeScriptEnum {
     }
 
     /// Check if an enum declaration can be safely removed (post-inlining).
-    /// Const enums are always removed when `optimize_const_enums` is set.
-    /// Regular enums are removed only if all references were inlined away by `enter_expression`.
+    ///
+    /// The decl is removable when no value references (`Read`/`Write`) remain —
+    /// `enter_expression` inlines member accesses and deletes those references. Type
+    /// references (e.g. from `as E` / `: E`) are kept here and stripped later by
+    /// `annotations.rs`, so they don't block removal.
+    ///
+    /// If a non-inlinable value reference remains (e.g. `export default E`, `E.toString()`),
+    /// we emit the IIFE form so the binding still exists at runtime — matching tsc under
+    /// `--isolatedModules`. Babel drops the declaration in this case, leaving dangling
+    /// references; oxc diverges intentionally to preserve runtime correctness.
     fn can_remove_enum(&self, decl: &TSEnumDeclaration<'a>, ctx: &TraverseCtx<'a>) -> bool {
-        self.may_remove_enum(decl, ctx)
-            && (decl.r#const
-                || ctx.scoping().get_resolved_reference_ids(decl.id.symbol_id()).is_empty())
+        if !self.may_remove_enum(decl, ctx) {
+            return false;
+        }
+        ctx.scoping().get_resolved_references(decl.id.symbol_id()).all(|r| !r.is_value())
     }
 
     /// Check if all members of an enum declaration have known constant values.

tasks/transform_conformance/snapshots/babel.snap.md

@@ -2303,26 +2303,10 @@ x Output mismatch
 x Output mismatch
 
 * optimize-const-enums/local/input.ts
-Reference symbol mismatch for "A":
-after transform: SymbolId(0) "A"
-rebuilt        : <None>
-Reference symbol mismatch for "A":
-after transform: SymbolId(0) "A"
-rebuilt        : <None>
-Unresolved references mismatch:
-after transform: []
-rebuilt        : ["A"]
+x Output mismatch
 
 * optimize-const-enums/merged/input.ts
-Reference symbol mismatch for "A":
-after transform: SymbolId(0) "A"
-rebuilt        : <None>
-Reference symbol mismatch for "A":
-after transform: SymbolId(0) "A"
-rebuilt        : <None>
-Unresolved references mismatch:
-after transform: []
-rebuilt        : ["A"]
+x Output mismatch
 
 * optimize-const-enums/merged-exported/input.ts
 x Output mismatch

tasks/transform_conformance/snapshots/oxc.snap.md

@@ -1,6 +1,6 @@
 commit: 4079bcda
 
-Passed: 235/383
+Passed: 236/385
 
 # All Passed:
 * babel-plugin-transform-class-static-block
@@ -63,7 +63,7 @@ after transform: SymbolId(0): [ReferenceId(0), ReferenceId(2), ReferenceId(6), R
 rebuilt        : SymbolId(0): [ReferenceId(0), ReferenceId(2), ReferenceId(6), ReferenceId(10)]
 
 
-# babel-plugin-transform-typescript (23/58)
+# babel-plugin-transform-typescript (24/60)
 * allow-declare-fields-false/input.ts
 Unresolved references mismatch:
 after transform: ["dce"]
@@ -118,6 +118,28 @@ Unresolved reference IDs mismatch for "Infinity":
 after transform: [ReferenceId(0), ReferenceId(1), ReferenceId(2), ReferenceId(3), ReferenceId(8), ReferenceId(11), ReferenceId(14), ReferenceId(18)]
 rebuilt        : [ReferenceId(2), ReferenceId(5), ReferenceId(8), ReferenceId(12)]
 
+* const-enum-mixed-refs/input.ts
+Bindings mismatch:
+after transform: ScopeId(1): ["Phase", "one", "two"]
+rebuilt        : ScopeId(1): ["Phase"]
+Scope flags mismatch:
+after transform: ScopeId(1): ScopeFlags(0x0)
+rebuilt        : ScopeId(1): ScopeFlags(Function)
+Symbol flags mismatch for "Phase":
+after transform: SymbolId(0): SymbolFlags(ConstEnum)
+rebuilt        : SymbolId(0): SymbolFlags(FunctionScopedVariable)
+
+* const-enum-value-ref-kept/input.ts
+Bindings mismatch:
+after transform: ScopeId(1): ["Phase", "one", "two"]
+rebuilt        : ScopeId(1): ["Phase"]
+Scope flags mismatch:
+after transform: ScopeId(1): ScopeFlags(0x0)
+rebuilt        : ScopeId(1): ScopeFlags(Function)
+Symbol flags mismatch for "Phase":
+after transform: SymbolId(0): SymbolFlags(ConstEnum)
+rebuilt        : SymbolId(0): SymbolFlags(FunctionScopedVariable)
+
 * elimination-declare/input.ts
 Bindings mismatch:
 after transform: ScopeId(0): ["A", "ReactiveMarker", "ReactiveMarkerSymbol"]
@@ -526,20 +548,6 @@ Symbol flags mismatch for "B":
 after transform: SymbolId(2): SymbolFlags(RegularEnum)
 rebuilt        : SymbolId(2): SymbolFlags(FunctionScopedVariable)
 
-* optimize-enums/type-cast/input.ts
-Bindings mismatch:
-after transform: ScopeId(1): ["Direction", "Down", "Up"]
-rebuilt        : ScopeId(1): ["Direction"]
-Scope flags mismatch:
-after transform: ScopeId(1): ScopeFlags(0x0)
-rebuilt        : ScopeId(1): ScopeFlags(Function)
-Symbol flags mismatch for "Direction":
-after transform: SymbolId(0): SymbolFlags(RegularEnum)
-rebuilt        : SymbolId(0): SymbolFlags(FunctionScopedVariable)
-Symbol reference IDs mismatch for "Direction":
-after transform: SymbolId(0): [ReferenceId(5), ReferenceId(1), ReferenceId(7), ReferenceId(3), ReferenceId(14)]
-rebuilt        : SymbolId(0): [ReferenceId(5)]
-
 * optimize-enums/typeof-kept/input.ts
 Bindings mismatch:
 after transform: ScopeId(1): ["Bar", "X"]

tasks/transform_conformance/tests/babel-plugin-transform-typescript/test/fixtures/const-enum-mixed-refs/input.ts

@@ -0,0 +1,10 @@
+// Member accesses are inlined; the bare value reference forces the IIFE
+// to be kept so the runtime binding still exists.
+const enum Phase {
+  one = "one",
+  two = "two",
+}
+
+const a = Phase.one;
+const b = Phase.two;
+const c = Phase;

tasks/transform_conformance/tests/babel-plugin-transform-typescript/test/fixtures/const-enum-mixed-refs/options.json

@@ -0,0 +1,3 @@
+{
+  "plugins": [["transform-typescript", { "optimizeConstEnums": true }]]
+}

tasks/transform_conformance/tests/babel-plugin-transform-typescript/test/fixtures/const-enum-mixed-refs/output.js

@@ -0,0 +1,8 @@
+var Phase = /* @__PURE__ */ function(Phase) {
+  Phase["one"] = "one";
+  Phase["two"] = "two";
+  return Phase;
+}(Phase || {});
+const a = "one";
+const b = "two";
+const c = Phase;

tasks/transform_conformance/tests/babel-plugin-transform-typescript/test/fixtures/const-enum-value-ref-kept/input.ts

@@ -0,0 +1,9 @@
+// `export default <enum>` is a bare value reference that can't be inlined.
+// The IIFE form must be emitted so the binding still exists at runtime,
+// otherwise the export resolves to `undefined`/ReferenceError.
+const enum Phase {
+  one = "one",
+  two = "two",
+}
+
+export default Phase;

tasks/transform_conformance/tests/babel-plugin-transform-typescript/test/fixtures/const-enum-value-ref-kept/options.json

@@ -0,0 +1,3 @@
+{
+  "plugins": [["transform-typescript", { "optimizeConstEnums": true }]]
+}

tasks/transform_conformance/tests/babel-plugin-transform-typescript/test/fixtures/const-enum-value-ref-kept/output.js

@@ -0,0 +1,6 @@
+var Phase = /* @__PURE__ */ function(Phase) {
+  Phase["one"] = "one";
+  Phase["two"] = "two";
+  return Phase;
+}(Phase || {});
+export default Phase;

tasks/transform_conformance/tests/babel-plugin-transform-typescript/test/fixtures/optimize-enums/type-cast/output.js

@@ -1,8 +1,3 @@
-var Direction = /* @__PURE__ */ function(Direction) {
-  Direction[Direction["Up"] = 0] = "Up";
-  Direction[Direction["Down"] = 1] = "Down";
-  return Direction;
-}(Direction || {});
 0;
 1;
 0;