feat: const enum cross-module inlining support

[Dunqing]

Summary

Enable cross-module enum inlining by consuming pre-computed enum member values from oxc_semantic.

Depends on: oxc-project/oxc#20652

closes #4342

What changed

• Extract enum values from initial Scoping before the transformer converts enums to IIFEs/placeholders
• Store on EcmaView as enum_member_value_map (name-keyed, survives transformer rewrites)
• Inline enum member accesses in the scope hoisting finalizer:
  • Direction.Up → 0 (dot notation)
  • Direction["Up"] → 0 (bracket notation)
  • ns.Direction.Up → 0 (chained namespace access)
• Tree-shake dead enum declarations when all references are inlined member accesses
• Supports both const enum and regular enum when all members have statically known values
• Enables oxc's optimize_const_enums and optimize_enums transformer options

Architecture

The enum inlining pipeline follows Rolldown's existing module processing stages:

┌─ Scan Stage (per module) ──────────────────────────────────────────┐
│                                                                     │
│  pre_process_ecma_ast.rs                                           │
│  ├─ Step 1: SemanticBuilder → Scoping                              │
│  ├─ Step 1.5: Extract enum_member_value_map from Scoping           │
│  │            (before transformer destroys enum declarations)       │
│  ├─ Step 3: Transformer (optimize_const_enums + optimize_enums)    │
│  │           const enums → removed, regular enums → @__PURE__ IIFE │
│  └─ Returns ParseToEcmaAstResult { enum_member_value_map, ... }    │
│                                                                     │
│  ecma_module_view_factory.rs                                        │
│  ├─ AstScanner: scans AST for imports/exports/statements           │
│  └─ enum_member_value_map stored directly on EcmaView              │
│     (bypasses AstScanner — no symbol-level processing needed)       │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

┌─ Link Stage ───────────────────────────────────────────────────────┐
│                                                                     │
│  include_statements.rs (tree-shaking)                               │
│  ├─ Computes has_enum_inlining once for the whole bundle           │
│  └─ For member expr refs (e.g. B.member):                          │
│     if member exists in enum_member_value_map → skip including     │
│     the enum declaration (it will be inlined, declaration is dead)  │
│                                                                     │
│  has_enum_inlining stored on LinkStageOutput for generate stage    │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

┌─ Generate Stage ───────────────────────────────────────────────────┐
│                                                                     │
│  ScopeHoistingFinalizer (impl_visit_mut.rs + mod.rs)               │
│  ├─ visit_expression: try_inline_enum_access() before other        │
│  │   member expr rewrites                                          │
│  ├─ After namespace rewrite (ns.E → E): retry enum inlining       │
│  └─ try_inline_enum_member_by_ref: canonical_ref → owner module   │
│     → enum_member_value_map → literal value                        │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

Comparison with other tools

Feature	Rolldown (this PR)	esbuild	TypeScript (tsc)
Const enum inlining	Yes	Yes	Yes (same-file only with --isolatedModules)
Regular enum inlining	Yes	Yes	No
Cross-module const enum	Yes	Yes	No (with --isolatedModules)
Optional chaining (E?.X)	No	No	No
Computed access (E["X"])	Yes	Yes	Yes
Namespace chains (ns.E.X)	Yes	Yes	N/A
Tree-shake dead enum decls	Yes	Yes	No
Merged/sibling enums	Yes	Yes	Yes

Performance

• has_enum_inlining flag computed once during link stage, reused by generate stage
• Fast-path skip in visitor hot loop for enum-free bundles

Test plan

• ts_enum_cross_module_inlining_access — direct + computed member access inlined
• ts_enum_cross_module_inlining_edge_cases — renamed re-exports, namespace re-exports, mixed value types, const vs regular
• ts_enum_cross_module_inlining_definitions — enum definitions handled correctly
• ts_enum_cross_module_inlining_re_export — chained ns.Enum.Member inlined
• ts_enum_cross_module_tree_shaking — dead enum declarations removed
• ts_enum_same_module_inlining_access — same-module accesses inlined
• ts_const_enum_comments — const enum member accesses inlined
• ts_sibling_enum — merged enum declarations resolved correctly
• cross_module_constant_folding_* — number, string, computed property name folding
• Full enum test suite: 15 passed, 0 failed

Known limitations

• Optional chaining on enums (E?.X) not inlined (matches esbuild behavior)
• Comment annotations (/* Direction.Up */) on inlined values not yet implemented

🤖 Generated with Claude Code

[netlify]

✅ Deploy Preview for rolldown-rs canceled.

Name	Link
🔨 Latest commit	c682675
🔍 Latest deploy log	https://app.netlify.com/projects/rolldown-rs/deploys/69df9a8850b5ad00083b186d

[Dunqing]

All tests passed locally; I think it is ready for review for this round. cc @IWANABETHATGUY

[hyf0]

LGTM. Very good job!

[Dunqing]

READY FOR REVIEW NOW

[codspeed-hq]

Merging this PR will not alter performance

✅ 4 untouched benchmarks
⏩ 10 skipped benchmarks¹

---

_{Comparing oxc/const-enum (c682675) with main (ec42e53)}

Footnotes

1. 10 benchmarks were skipped, so the baseline results were used instead. If they were deleted from the codebase, click here and archive them to remove them from the performance reports. ↩