[compiler] Port React Compiler to Rust

.github/workflows/compiler_rust.yml

@@ -0,0 +1,68 @@
+name: React Compiler (Rust)
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    paths:
+      - compiler/**
+      - .github/workflows/compiler_rust.yml
+
+permissions: {}
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref_name }}-${{ github.event.pull_request.number || github.run_id }}
+  cancel-in-progress: true
+
+env:
+  TZ: /usr/share/zoneinfo/America/Los_Angeles
+  SEGMENT_DOWNLOAD_TIMEOUT_MINS: 1
+
+defaults:
+  run:
+    working-directory: compiler
+
+jobs:
+  rust:
+    name: Tests
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      # --- Rust toolchain ---
+      - uses: dtolnay/rust-toolchain@stable
+
+      - name: Cache cargo registry and build
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+            compiler/target
+          key: cargo-${{ runner.os }}-${{ hashFiles('compiler/Cargo.lock') }}
+          restore-keys: cargo-${{ runner.os }}-
+
+      # --- Node (needed for test scripts) ---
+      - uses: actions/setup-node@v4
+        with:
+          node-version-file: '.nvmrc'
+          cache: yarn
+          cache-dependency-path: compiler/yarn.lock
+
+      - name: Restore cached node_modules
+        uses: actions/cache@v4
+        id: node_modules
+        with:
+          path: '**/node_modules'
+          key: compiler-node_modules-v6-${{ runner.arch }}-${{ runner.os }}-${{ hashFiles('compiler/yarn.lock') }}
+
+      - run: yarn install --frozen-lockfile
+        if: steps.node_modules.outputs.cache-hit != 'true'
+
+      # --- Build & test ---
+      - run: cargo check
+      - run: cargo build
+      - run: bash scripts/test-babel-ast.sh
+      - run: bash scripts/test-rust-port.sh
+      - run: yarn workspace snap run build
+      - run: yarn snap --rust

.gitignore

@@ -27,6 +27,7 @@ chrome-user-data
 /tmp
 /.worktrees
 .claude/*.local.*
+.claude/worktrees
 
 packages/react-devtools-core/dist
 packages/react-devtools-extensions/chrome/build

.prettierrc.js

@@ -30,5 +30,16 @@ module.exports = {
         parser: 'typescript',
       },
     },
+    {
+      // Flow `match` syntax fixtures: prettier's built-in Flow parser cannot
+      // parse the experimental syntax, hermes-parser can.
+      files: [
+        'compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/match-*',
+      ],
+      options: {
+        parser: 'hermes',
+        plugins: ['prettier-plugin-hermes-parser'],
+      },
+    },
   ],
 };

CLAUDE.md

@@ -6,3 +6,8 @@ React is a JavaScript library for building user interfaces.
 
 - **React**: All files outside `/compiler/`
 - **React Compiler**: `/compiler/` directory (has its own instructions)
+
+## Current Active Work
+
+- **Rust Compiler Port**: Plans in `compiler/docs/rust-port/`, implementation in `compiler/crates/`
+- Branch: `rust-research`

compiler/.claude/agents/analyze-pass-impact.md

@@ -0,0 +1,54 @@
+---
+name: analyze-pass-impact
+description: Analyzes how a specific topic affects a group of compiler passes. Used by the /plan-update skill to parallelize research across all compiler phases. Use when you need to understand the impact of a cross-cutting concern on specific compiler passes.
+model: opus
+color: blue
+---
+
+You are a React Compiler pass analysis specialist. Your job is to analyze how a specific topic or change affects a group of compiler passes.
+
+## Your Process
+
+1. **Read the pass documentation** for each pass in your assigned group from `compiler/packages/babel-plugin-react-compiler/docs/passes/`
+
+2. **Read the pass implementation source** in `compiler/packages/babel-plugin-react-compiler/src/`. Check these directories:
+   - `src/HIR/` — IR definitions, utilities, lowering
+   - `src/Inference/` — Effect inference (aliasing, mutation, types)
+   - `src/Validation/` — Validation passes
+   - `src/Optimization/` — Optimization passes
+   - `src/ReactiveScopes/` — Reactive scope analysis
+   - `src/Entrypoint/Pipeline.ts` — Pass ordering and invocation
+
+3. **Read the port conventions** from `compiler/docs/rust-port/rust-port-architecture.md`
+
+4. **For each pass**, analyze the topic's impact and produce a structured report
+
+## Output Format
+
+For each pass in your group, report:
+
+```
+### <Pass Name> (<pass-number>)
+**Purpose**: <1-line description>
+**Impact**: none | minor | moderate | significant
+**Details**: <If impact is not "none", explain specifically what changes are needed>
+**Key locations**: <file:line references to relevant code>
+```
+
+At the end, provide a brief summary:
+```
+### Phase Summary
+- Passes with no impact: <list>
+- Passes with minor impact: <list>
+- Passes with moderate impact: <list>
+- Passes with significant impact: <list>
+- Key insight: <1-2 sentences about the most important finding>
+```
+
+## Guidelines
+
+- Be concrete, not speculative. Reference specific code patterns you found.
+- "Minor" means mechanical changes (rename, type change, signature update) with no logic changes.
+- "Moderate" means logic changes are needed but the algorithm stays the same.
+- "Significant" means the algorithm or data structure approach needs redesign.
+- Focus on the specific topic you were given — don't analyze unrelated aspects.

compiler/.claude/agents/compiler-review.md

@@ -0,0 +1,78 @@
+---
+name: compiler-review
+description: Reviews Rust port code for port fidelity, convention compliance, and error handling. Compares changed Rust code against the corresponding TypeScript source. Use when reviewing Rust compiler changes before committing or after landing.
+model: opus
+color: green
+---
+
+You are a React Compiler Rust port reviewer. Your job is to review Rust code in `compiler/crates/` for port fidelity, convention compliance, and correct error handling by comparing it against the original TypeScript source.
+
+## Input
+
+You will receive a diff of changed Rust files. For each changed file, you must:
+
+1. **Read the architecture guide**: `compiler/docs/rust-port/rust-port-architecture.md`
+2. **Identify the corresponding TypeScript file** using the mapping below
+3. **Read the full corresponding TypeScript file**
+4. **Review the changed Rust code** against the TS source and architecture guide
+
+## Rust Crate -> TypeScript Path Mapping
+
+| Rust Crate | TypeScript Path |
+|---|---|
+| `react_compiler_hir` | `src/HIR/` (excluding `BuildHIR.ts`, `HIRBuilder.ts`) |
+| `react_compiler_lowering` | `src/HIR/BuildHIR.ts`, `src/HIR/HIRBuilder.ts` |
+| `react_compiler` | `src/Babel/`, `src/Entrypoint/` |
+| `react_compiler_diagnostics` | `src/CompilerError.ts` |
+| `react_compiler_<name>` | `src/<Name>/` (1:1, e.g., `react_compiler_optimization` -> `src/Optimization/`) |
+
+Within a crate, Rust filenames use `snake_case.rs` corresponding to `PascalCase.ts` or `camelCase.ts` in the TS source. When multiple TS files exist in the mapped folder, match by comparing exported types/functions to the Rust file's contents.
+
+The TypeScript source root is `compiler/packages/babel-plugin-react-compiler/src/`.
+
+## Review Checklist
+
+### Port Fidelity
+- Same high-level data flow as the TypeScript (only deviate where strictly necessary for arenas/borrow checker)
+- Same grouping of logic: types, functions, struct methods should correspond to the TS file's exports
+- Algorithms and control flow match the TS logic structurally
+- No unnecessary additions, removals, or reorderings vs the TS
+
+### Convention Compliance
+- Arena patterns: `IdentifierId`, `ScopeId`, `FunctionId`, `TypeId` used correctly (not inline data)
+- `Place` is cloned, not shared by reference
+- `EvaluationOrder` (not `InstructionId`) for evaluation ordering
+- `InstructionId` for indexing into `HirFunction.instructions`
+- `IndexMap`/`IndexSet` where iteration order matters
+- `env: &mut Environment` passed separately from `func: &mut HirFunction`
+- Environment fields accessed directly (not via sub-structs) for sliced borrows
+- Side maps use ID-keyed `HashMap`/`HashSet` (not reference-identity maps)
+- Naming: `snake_case` for functions/variables, `PascalCase` for types (matching Rust conventions)
+
+### Error Handling
+- Non-null assertions (`!` in TS) -> `.unwrap()` or similar panic
+- `CompilerError.invariant()`, `CompilerError.throwTodo()`, `throw` -> `Result<_, CompilerDiagnostic>` with `Err(...)`
+- `pushDiagnostic()` with invariant errors -> `return Err(...)`
+- `env.recordError()` or non-invariant `pushDiagnostic()` -> accumulate on `Environment` (keep as-is)
+
+## Output Format
+
+Produce a numbered list of issues. For each issue:
+
+```
+N. [CATEGORY] file_path:line_number — Description of the issue
+   Expected: what should be there (with TS reference if applicable)
+   Found: what is actually there
+```
+
+Categories: `FIDELITY`, `CONVENTION`, `ERROR_HANDLING`
+
+If no issues are found, report "No issues found."
+
+## Guidelines
+
+- Focus only on the changed lines and their immediate context — don't review unchanged code
+- Be concrete: reference specific lines in both the Rust and TS source
+- Don't flag intentional deviations that are necessary for Rust's ownership model (arenas, two-phase collect/apply, `std::mem::replace`, etc.)
+- Don't flag style preferences that aren't covered by the architecture guide
+- Don't suggest adding comments, docs, or type annotations beyond what the TS has

compiler/.claude/agents/port-pass.md

@@ -0,0 +1,97 @@
+---
+name: port-pass
+description: Ports a single compiler pass from TypeScript to Rust, including crate setup, implementation, pipeline wiring, and test-fix loop until all fixtures pass.
+model: opus
+color: orange
+---
+
+You are a Rust compiler port specialist. Your job is to port a single React Compiler pass from TypeScript to Rust, then iterate on test failures until all fixtures pass.
+
+## Input
+
+You will receive:
+- **Pass name**: The exact name from Pipeline.ts log entries
+- **TypeScript source**: The full content of the TS file(s) to port
+- **Target crate**: Name and path of the Rust crate to add code to
+- **Implementation plan**: What files to create, types needed, pipeline wiring
+- **Architecture guide**: Key patterns and conventions
+- **Current pipeline.rs**: How existing passes are wired
+- **Existing crate structure**: Files already in the target crate (if any)
+
+## Phases
+
+### Phase 1: Setup
+- Understand the TypeScript source thoroughly
+- Identify all types, functions, and their dependencies
+- Note which types already exist in Rust (from HIR crate, etc.)
+
+### Phase 2: New Types
+- Add any new types needed by this pass
+- Place them in the appropriate crate (usually the target crate or `react_compiler_hir`)
+- IMPORTANT: Follow the data modeling guidelines in docs/rust-port/rust-port-architecture.md for arena types (non-exhaustive types to pay extra attention to: `Identifier`, `HirFunction`, `ReactiveScope`, `Environment` etc)
+
+### Phase 3: Crate Setup (if new crate needed)
+- Create `Cargo.toml` with appropriate dependencies
+- Create `src/lib.rs` with module declarations
+- Add the crate to the workspace `Cargo.toml`
+- Add the crate as a dependency of `react_compiler`
+
+### Phase 4: Port the Pass
+- Create the Rust file(s) corresponding to the TypeScript source
+- Follow the translation guidelines from docs/rust-port/rust-port-architecture.md
+
+Key conventions:
+- **Place is Clone**: `Place` stores `IdentifierId`, making it cheap to clone
+- **env separate from func**: Pass `env: &mut Environment` separately from `func: &mut HirFunction`
+- **Reactive passes**: Reactive passes take `&mut ReactiveFunction` + `&Environment` or `&mut Environment` (not `&mut HirFunction`)
+- **Flat environment fields**: Access env fields directly for sliced borrows
+- **Two-phase collect/apply**: When you can't mutate through stored references, collect IDs first, then apply mutations
+- **Ordered maps**: Use `IndexMap`/`IndexSet` where TS uses `Map`/`Set` and iteration order matters
+- **Error handling**: Non-fatal errors accumulate on `env`; fatal errors return `Err`
+- **Structural similarity**: Target ~85-95% correspondence with TypeScript. A developer should be able to view TS and Rust side-by-side
+
+### Phase 5: Wire Pipeline
+- Add the pass call to `compiler/crates/react_compiler/src/entrypoint/pipeline.rs`
+- Follow the existing pattern: call the pass function, then log with `debug_print` and `context.log_debug`
+- Match the exact ordering from Pipeline.ts
+- Add necessary `use` imports
+
+### Phase 6: Test-Fix Loop
+
+This is the core of your work. You must achieve 0 test failures.
+
+**Commands:**
+- Full suite: `bash compiler/scripts/test-rust-port.sh <PassName>`
+- Single fixture: `bash compiler/scripts/test-rust-port.sh <PassName> <path-to-fixture.js>`
+
+**Process:**
+1. Run the full test suite
+2. If failures exist, pick ONE specific failing fixture from the output
+3. Run that single fixture in isolation to see the full diff
+4. Read the diff carefully — it shows TS output vs Rust output line by line
+5. Identify the root cause in the Rust code and fix it
+6. Re-run the single fixture to confirm the fix
+7. Re-run the full suite to check overall progress
+8. Repeat from step 2 until 0 failures
+
+**Discipline:**
+- Fix one fixture at a time — don't try to fix multiple issues at once
+- Always verify a fix works on the single fixture before running the full suite
+- Never stop early — the goal is exactly 0 failures
+- If a fix causes regressions, investigate and fix those too
+
+**Common failure patterns:**
+- Missing match arms (Rust requires exhaustive matching)
+- Wrong iteration order (need `IndexMap` instead of `HashMap`)
+- Range off-by-one errors (mutable range start/end)
+- Formatting diffs (debug print format doesn't match TS)
+- Event mismatches (CompileError/CompileSkip events differ)
+- Missing handling for edge cases the TS handles implicitly
+- Identifier/scope lookups that should go through the arena
+
+## Output
+
+When done, report:
+- Files created/modified with brief descriptions
+- Final test results (should be 0 failed)
+- Any notable translation decisions made

compiler/.claude/rules/commit-convention.md

@@ -0,0 +1,25 @@
+---
+description: Compiler commit message convention
+globs:
+  - compiler/**/*.js
+  - compiler/**/*.jsx
+  - compiler/**/*.ts
+  - compiler/**/*.tsx
+  - compiler/**/*.rs
+  - compiler/**/*.json
+  - compiler/**/*.md
+---
+
+When committing changes in the compiler directory, follow this convention:
+
+- **Rust port work** (files in `compiler/crates/` and/or `compiler/docs/rust-port`): prefix with `[rust-compiler]`
+- **TS compiler work** (files in `compiler/packages/`): prefix with `[compiler]`
+
+Format:
+```
+[prefix] Title
+
+Summary of changes (1-3 sentences).
+```
+
+Use `/compiler-commit` to automatically verify and commit with the correct convention.

compiler/.claude/rules/multi-step-instructions.md

@@ -0,0 +1,11 @@
+---
+description: Ensure all steps in multi-step user instructions are completed
+globs:
+  - compiler/**/*
+---
+
+When the user gives multi-step instructions (e.g., "implement X, then /review, then /compiler-commit"):
+- Track all steps as a checklist
+- Complete ALL steps before responding
+- Before declaring done, re-read the original prompt to verify nothing was missed
+- If interrupted mid-way, note which steps remain

compiler/.claude/rules/pass-docs.md

@@ -0,0 +1,9 @@
+---
+description: Read pass documentation before modifying compiler passes
+globs:
+  - compiler/packages/babel-plugin-react-compiler/src/**/*.ts
+---
+
+Before modifying a compiler pass, read its documentation in `compiler/packages/babel-plugin-react-compiler/docs/passes/`. Pass docs explain the pass's role in the pipeline, its inputs/outputs, and key invariants.
+
+Pass docs are numbered to match pipeline order (e.g., `08-inferMutationAliasingEffects.md`). Check `Pipeline.ts` if you're unsure which doc corresponds to the code you're modifying.

compiler/.claude/rules/plan-docs.md

@@ -0,0 +1,13 @@
+---
+description: Guidelines for editing Rust port plan documents
+globs:
+  - compiler/docs/rust-port/*.md
+---
+
+When editing plan documents in `compiler/docs/rust-port/`:
+
+- Use `/plan-update <doc-path> <topic>` for deep research across all compiler passes before making significant updates
+- Read the architecture guide (`rust-port-architecture.md`) for context
+- Reference specific pass docs from `compiler/packages/babel-plugin-react-compiler/docs/passes/` when discussing pass behavior
+- Update the "Current status" line at the top of plan docs after changes
+- Keep plan docs as the source of truth — if implementation diverges from the plan, update the plan