## 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

- [x] `ts_enum_cross_module_inlining_access` — direct + computed member
access inlined
- [x] `ts_enum_cross_module_inlining_edge_cases` — renamed re-exports,
namespace re-exports, mixed value types, const vs regular
- [x] `ts_enum_cross_module_inlining_definitions` — enum definitions
handled correctly
- [x] `ts_enum_cross_module_inlining_re_export` — chained
`ns.Enum.Member` inlined
- [x] `ts_enum_cross_module_tree_shaking` — dead enum declarations
removed
- [x] `ts_enum_same_module_inlining_access` — same-module accesses
inlined
- [x] `ts_const_enum_comments` — const enum member accesses inlined
- [x] `ts_sibling_enum` — merged enum declarations resolved correctly
- [x] `cross_module_constant_folding_*` — number, string, computed
property name folding
- [x] 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](https://claude.com/claude-code)