[compiler] Phase 4 (batch 1): Update validation passes to record errors on env

Update 9 validation passes to record errors directly on fn.env instead of
returning Result<void, CompilerError>:
- validateHooksUsage
- validateNoCapitalizedCalls (also changed throwInvalidReact to recordError)
- validateUseMemo
- dropManualMemoization
- validateNoRefAccessInRender
- validateNoSetStateInRender
- validateNoImpureFunctionsInRender
- validateNoFreezingKnownMutableFunctions
- validateExhaustiveDependencies

Each pass now calls fn.env.recordErrors() instead of returning errors.asResult().
Pipeline.ts call sites updated to remove tryRecord() wrappers and .unwrap().

compiler/CLAUDE.md

@@ -35,20 +35,6 @@ yarn snap -p <file-basename> -d
 yarn snap -u
 ```
 
-## Linting
-
-```bash
-# Run lint on the compiler source
-yarn workspace babel-plugin-react-compiler lint
-```
-
-## Formatting
-
-```bash
-# Run prettier on all files (from the react root directory, not compiler/)
-yarn prettier-all
-```
-
 ## Compiling Arbitrary Files
 
 Use `yarn snap compile` to compile any file (not just fixtures) with the React Compiler:
@@ -243,19 +229,20 @@ Would enable the `enableJsxOutlining` feature and disable the `enableNameAnonymo
 3. Look for `Impure`, `Render`, `Capture` effects on instructions
 4. Check the pass ordering in Pipeline.ts to understand when effects are populated vs validated
 
-## Error Handling and Fault Tolerance
+## Error Handling for Unsupported Features
 
-The compiler is fault-tolerant: it runs all passes and accumulates errors on the `Environment` rather than throwing on the first error. This lets users see all compilation errors at once.
+When the compiler encounters an unsupported but known pattern, use `CompilerError.throwTodo()` instead of `CompilerError.invariant()`. Todo errors cause graceful bailouts in production; Invariant errors are hard failures indicating unexpected/invalid states.
 
-**Recording errors** — Passes record errors via `env.recordError(diagnostic)`. Errors are accumulated on `Environment.#errors` and checked at the end of the pipeline via `env.hasErrors()` / `env.aggregateErrors()`.
+```typescript
+// Unsupported but expected pattern - graceful bailout
+CompilerError.throwTodo({
+  reason: `Support [description of unsupported feature]`,
+  loc: terminal.loc,
+});
 
-**`tryRecord()` wrapper** — In Pipeline.ts, validation passes are wrapped in `env.tryRecord(() => pass(hir))` which catches thrown `CompilerError`s (non-invariant) and records them. Infrastructure/transformation passes are NOT wrapped in `tryRecord()` because later passes depend on their output being structurally valid.
-
-**Error categories:**
-- `CompilerError.throwTodo()` — Unsupported but known pattern. Graceful bailout. Can be caught by `tryRecord()`.
-- `CompilerError.invariant()` — Truly unexpected/invalid state. Always throws immediately, never caught by `tryRecord()`.
-- Non-`CompilerError` exceptions — Always re-thrown.
-
-**Key files:** `Environment.ts` (`recordError`, `tryRecord`, `hasErrors`, `aggregateErrors`), `Pipeline.ts` (pass orchestration), `Program.ts` (`tryCompileFunction` handles the `Result`).
-
-**Test fixtures:** `__tests__/fixtures/compiler/fault-tolerance/` contains multi-error fixtures verifying all errors are reported.
+// Invariant is for truly unexpected/invalid states - hard failure
+CompilerError.invariant(false, {
+  reason: `Unexpected [thing]`,
+  loc: terminal.loc,
+});
+```

compiler/fault-tolerance-overview.md

@@ -0,0 +1,327 @@
+## React Compiler Fault Tolerance
+
+Update React Compiler (@compiler/ directory) to always run all passes and return either the transformed code (if no error) or a list of one or more compilation errors. 
+
+## Background
+
+Currently React Compiler runs through a series of passes in Pipeline.ts. If an error occurs in a pass the compiler will generally either throw the error in the pass where it occurs, or return a Result<_, CompilerError> which is then unwrapped in Pipeline.ts, throwing there. This means that a single error that triggers early can prevent later validation from running, meaning the user has to first fix one error in order to see another.
+
+## New Approach
+
+The compiler should always run all passes in the pipeline, up to and including CodegenReactiveFunction. During this process it should accumulate errors. If at the end of compilation there were no accumulated errors, return `Ok(generatedfunction)`. Else, return `Err(CompilerError)` with *all* the accumulated errors.
+
+Note that some errors may continue to cause an eager bailout:
+* If an error is not an instanceof CompilerError, throw it as it occurs
+* If an error is a CompilerError invariant, throw it as it occurs since this represents a truly exceptional, unexpected case
+
+## Detailed Design
+
+* The Environment needs a way to record errors as compilation proceeds. This should generally store the error (and log, if a logger is configured), but should immediately throw if the error is an invariant (see above).
+* BuildHIR should always produce an HIR without error. For syntax forms that are unsupported (currently throwing a Todo error), we should instead construct record the todo error on the environment, and construct a partial HIR. The exact form of the partial HIR can be situation specific:
+  * `var` is currently unsupported, but we could pretend it was `let`
+  * `finally` blocks are unsupported, we could just prune them, or move the code after the try/catch (put the finally logic in the consequent)
+  * This may mean updating the HIR to allow representing partial code
+  * `eval()` can just be an Unsupported InstructionValue variant
+* All of the passes need to be updated to stop returning Result or CompilerError, and instead record their errors on the environment. They should always be able to proceed even in the presence of errors. For example, in InferMutationAliasingEffects if we discover that the code mutates a frozen value, we can record this as an error and then just pretend the mutation didn't happen - ie construct a scope as if the mutating code was not a mutation after all.
+* Finally, the end of the pipeline should check for errors and either turn `Ok(GeneratedFunction)` or `Err(aggregatedErrors)`. The code calling into the pipeline then needs to handle this appropriately.
+
+## Detailed Plan
+
+### Phase 1: Environment Error Accumulation Infrastructure
+
+Add error accumulation to the `Environment` class so that any pass can record errors during compilation without halting.
+
+- [x] **1.1 Add error accumulator to Environment** (`src/HIR/Environment.ts`)
+  - Add a `#errors: CompilerError` field, initialized in the constructor
+  - Add a `recordError(error: CompilerDiagnostic | CompilerErrorDetail)` method that:
+    - If an Invariant-category detail, immediately throw it
+    - Otherwise, push the diagnostic/detail onto `#errors` (and log via `this.logger` if configured)
+  - Add a `recordErrors(error: CompilerError)` method that calls `recordError()` for each of the details on the given error.
+  - Add a `hasErrors(): boolean` getter
+  - Add a `aggregateErrors(): CompilerError` method that returns the accumulated error object
+  - Consider whether `recordError` should accept the same options as `CompilerError.push()` for convenience (reason, description, severity, loc, etc.)
+
+- [x] **1.2 Add a `tryRecord` helper on Environment** (`src/HIR/Environment.ts`)
+  - Add a `tryRecord(fn: () => void): void` method that wraps a callback in try/catch:
+    - If `fn` throws a `CompilerError` that is NOT an invariant, record it via `recordError`
+    - If `fn` throws a non-CompilerError or a CompilerError invariant, re-throw
+  - This helper is the migration path for passes that currently throw: wrap their call in `env.tryRecord(() => pass(hir))` so exceptions become recorded errors
+
+### Phase 2: Update Pipeline.ts to Accumulate Errors
+
+Change `runWithEnvironment` to run all passes and check for errors at the end instead of letting exceptions propagate.
+
+- [x] **2.1 Change `runWithEnvironment` return type** (`src/Entrypoint/Pipeline.ts`)
+  - Change return type from `CodegenFunction` to `Result<CodegenFunction, CompilerError>`
+  - At the end of the pipeline, check `env.hasErrors()`:
+    - If no errors: return `Ok(ast)`
+    - If errors: return `Err(env.aggregateErrors())`
+
+- [x] **2.2 Update `compileFn` to propagate the Result** (`src/Entrypoint/Pipeline.ts`)
+  - Change `compileFn` return type from `CodegenFunction` to `Result<CodegenFunction, CompilerError>`
+  - Propagate the Result from `runWithEnvironment`
+
+- [x] **2.3 Update `run` to propagate the Result** (`src/Entrypoint/Pipeline.ts`)
+  - Same change for the internal `run` function
+
+- [x] **2.4 Update callers in Program.ts** (`src/Entrypoint/Program.ts`)
+  - In `tryCompileFunction`, change from try/catch around `compileFn` to handling the `Result`:
+    - If `Ok(codegenFn)`: return the compiled function
+    - If `Err(compilerError)`: return `{kind: 'error', error: compilerError}`
+    - Keep the try/catch only for truly unexpected (non-CompilerError) exceptions and invariants
+  - The existing `handleError`/`logError`/`panicThreshold` logic in `processFn` should continue to work unchanged since it already handles `CompilerError` instances
+
+### Phase 3: Update BuildHIR (lower) to Always Produce HIR
+
+Currently `lower()` returns `Result<HIRFunction, CompilerError>`. It already accumulates errors internally via `builder.errors`, but returns `Err` when errors exist. Change it to always return `Ok(hir)` while recording errors on the environment.
+
+- [ ] **3.1 Change `lower` to always return HIRFunction** (`src/HIR/BuildHIR.ts`)
+  - Change return type from `Result<HIRFunction, CompilerError>` to `HIRFunction`
+  - Instead of returning `Err(builder.errors)` at line 227-229, record errors on `env` via `env.recordError(builder.errors)` and return the (partial) HIR
+  - Update the pipeline to call `lower(func, env)` directly instead of `lower(func, env).unwrap()`
+
+- [ ] **3.2 Handle `var` declarations as `let`** (`src/HIR/BuildHIR.ts`, line ~855)
+  - Currently throws `Todo("Handle var kinds in VariableDeclaration")`
+  - Instead: record the Todo error on env, then treat the `var` as `let` and continue lowering
+
+- [ ] **3.3 Handle `try/finally` by pruning `finally`** (`src/HIR/BuildHIR.ts`, lines ~1281-1296)
+  - Currently throws Todo for `try` without `catch` and `try` with `finally`
+  - Instead: record the Todo error, then lower the `try/catch` portion only (put the `finally` block content in the fallthrough of the try/catch)
+
+- [ ] **3.4 Handle `eval()` via UnsupportedNode** (`src/HIR/BuildHIR.ts`, line ~3568)
+  - Currently throws `UnsupportedSyntax("The 'eval' function is not supported")`
+  - Instead: record the error, emit an `UnsupportedNode` instruction value with the original AST node
+
+- [ ] **3.5 Handle `with` statement via UnsupportedNode** (`src/HIR/BuildHIR.ts`, line ~1382)
+  - Currently throws `UnsupportedSyntax`
+  - Instead: record the error, emit the body statements as-is (or skip them), continue
+
+- [ ] **3.6 Handle inline `class` declarations** (`src/HIR/BuildHIR.ts`, line ~1402)
+  - Currently throws `UnsupportedSyntax`
+  - Already creates an `UnsupportedNode`; just record the error instead of throwing
+
+- [ ] **3.7 Handle remaining Todo errors in expression lowering** (`src/HIR/BuildHIR.ts`)
+  - For each of the ~35 Todo error sites in `lowerExpression`, `lowerAssignment`, `lowerMemberExpression`, etc.:
+    - Record the Todo error on the environment
+    - Emit an `UnsupportedNode` instruction value with the original Babel AST node as fallback
+  - Key sites include: pipe operator, tagged templates with interpolations, compound logical assignment (`&&=`, `||=`, `??=`), `for await...of`, object getters/setters, UpdateExpression on context variables, complex destructuring patterns
+  - The `UnsupportedNode` variant already exists in HIR and passes through codegen unchanged, so no new HIR types are needed for most cases
+
+- [ ] **3.8 Handle `throw` inside `try/catch`** (`src/HIR/BuildHIR.ts`, line ~284)
+  - Currently throws Todo
+  - Instead: record the error, and represent the `throw` as a terminal that ends the block (the existing `throw` terminal type may already handle this, or we can use `UnsupportedNode`)
+
+- [ ] **3.9 Handle `for` loops with missing test or expression init** (`src/HIR/BuildHIR.ts`, lines ~559, ~632)
+  - Record the error and construct a best-effort loop HIR (e.g., for `for(;;)`, use `true` as the test expression)
+
+- [ ] **3.10 Handle nested function lowering failures** (`src/HIR/BuildHIR.ts`, `lowerFunction` at line ~3504)
+  - Currently calls `lower()` recursively and merges errors if it fails (`builder.errors.merge(functionErrors)`)
+  - With the new approach, the nested `lower()` always returns an HIR, but errors are recorded on the shared environment
+  - Ensure the parent function continues lowering even if a nested function had errors
+
+### Phase 4: Update Validation Passes
+
+All validation passes need to record errors on the environment instead of returning `Result` or throwing. They should still detect the same problems, but the pipeline should continue after each one.
+
+#### Pattern A passes (currently return `Result`, called with `.unwrap()`)
+
+These passes already accumulate errors internally and return `Result<void, CompilerError>`. The change is: instead of returning the Result, record errors on `env` and return void. Remove the `.unwrap()` call in Pipeline.ts.
+
+- [x] **4.1 `validateHooksUsage`** (`src/Validation/ValidateHooksUsage.ts`)
+  - Change signature from `(fn: HIRFunction): Result<void, CompilerError>` to `(fn: HIRFunction): void`
+  - Record errors on `fn.env` instead of returning `errors.asResult()`
+  - Update Pipeline.ts call site (line 211): remove `.unwrap()`
+
+- [x] **4.2 `validateNoCapitalizedCalls`** (`src/Validation/ValidateNoCapitalizedCalls.ts`)
+  - Change signature to return void
+  - Fix the hybrid pattern: the direct `CallExpression` path currently throws via `CompilerError.throwInvalidReact()` — change to record on env
+  - The `MethodCall` path already accumulates — change to record on env
+  - Update Pipeline.ts call site (line 214): remove `.unwrap()`
+
+- [x] **4.3 `validateUseMemo`** (`src/Validation/ValidateUseMemo.ts`)
+  - Change signature to return void
+  - Record hard errors on env instead of returning `errors.asResult()`
+  - The soft `voidMemoErrors` path already uses `env.logErrors()` — keep as-is or also record
+  - Update Pipeline.ts call site (line 170): remove `.unwrap()`
+
+- [x] **4.4 `dropManualMemoization`** (`src/Inference/DropManualMemoization.ts`)
+  - Change signature to return void
+  - Record errors on env instead of returning `errors.asResult()`
+  - Update Pipeline.ts call site (line 178): remove `.unwrap()`
+
+- [x] **4.5 `validateNoRefAccessInRender`** (`src/Validation/ValidateNoRefAccessInRender.ts`)
+  - Change signature to return void
+  - Record errors on env instead of returning Result
+  - Update Pipeline.ts call site (line 275): remove `.unwrap()`
+
+- [x] **4.6 `validateNoSetStateInRender`** (`src/Validation/ValidateNoSetStateInRender.ts`)
+  - Change signature to return void
+  - Record errors on env
+  - Update Pipeline.ts call site (line 279): remove `.unwrap()`
+
+- [x] **4.7 `validateNoImpureFunctionsInRender`** (`src/Validation/ValidateNoImpureFunctionsInRender.ts`)
+  - Change signature to return void
+  - Record errors on env
+  - Update Pipeline.ts call site (line 300): remove `.unwrap()`
+
+- [x] **4.8 `validateNoFreezingKnownMutableFunctions`** (`src/Validation/ValidateNoFreezingKnownMutableFunctions.ts`)
+  - Change signature to return void
+  - Record errors on env
+  - Update Pipeline.ts call site (line 303): remove `.unwrap()`
+
+- [x] **4.9 `validateExhaustiveDependencies`** (`src/Validation/ValidateExhaustiveDependencies.ts`)
+  - Change signature to return void
+  - Record errors on env
+  - Update Pipeline.ts call site (line 315): remove `.unwrap()`
+
+- [ ] **4.10 `validateMemoizedEffectDependencies`** (`src/Validation/ValidateMemoizedEffectDependencies.ts`)
+  - Change signature to return void (note: operates on `ReactiveFunction`)
+  - Record errors on the function's env
+  - Update Pipeline.ts call site (line 565): remove `.unwrap()`
+
+- [ ] **4.11 `validatePreservedManualMemoization`** (`src/Validation/ValidatePreservedManualMemoization.ts`)
+  - Change signature to return void (note: operates on `ReactiveFunction`)
+  - Record errors on the function's env
+  - Update Pipeline.ts call site (line 572): remove `.unwrap()`
+
+- [ ] **4.12 `validateSourceLocations`** (`src/Validation/ValidateSourceLocations.ts`)
+  - Change signature to return void
+  - Record errors on env
+  - Update Pipeline.ts call site (line 585): remove `.unwrap()`
+
+#### Pattern B passes (currently use `env.logErrors()`)
+
+These already use a soft-logging pattern and don't block compilation. They can be migrated to `env.recordError()` so all errors are aggregated in one place.
+
+- [ ] **4.13 `validateNoDerivedComputationsInEffects_exp`** — change to record on env directly
+- [ ] **4.14 `validateNoSetStateInEffects`** — change to record on env directly
+- [ ] **4.15 `validateNoJSXInTryStatement`** — change to record on env directly
+- [ ] **4.16 `validateStaticComponents`** — change to record on env directly
+
+#### Pattern D passes (currently throw directly, no Result)
+
+These throw `CompilerError` directly (not via Result). They need the most work.
+
+- [ ] **4.17 `validateContextVariableLValues`** (`src/Validation/ValidateContextVariableLValues.ts`)
+  - Currently throws via `CompilerError.throwTodo()` and `CompilerError.invariant()`
+  - Change to record Todo errors on env and continue
+  - Keep invariant throws (those indicate internal bugs)
+
+- [ ] **4.18 `validateLocalsNotReassignedAfterRender`** (`src/Validation/ValidateLocalsNotReassignedAfterRender.ts`)
+  - Currently constructs a `CompilerError` and `throw`s it directly
+  - Change to record errors on env
+
+- [ ] **4.19 `validateNoDerivedComputationsInEffects`** (`src/Validation/ValidateNoDerivedComputationsInEffects.ts`)
+  - Currently throws directly
+  - Change to record errors on env
+
+### Phase 5: Update Inference Passes
+
+The inference passes are the most critical to handle correctly because they produce side effects (populating effects on instructions, computing mutable ranges) that downstream passes depend on. They must continue producing valid (even if imprecise) output when errors are encountered.
+
+- [ ] **5.1 `inferMutationAliasingEffects`** (`src/Inference/InferMutationAliasingEffects.ts`)
+  - Currently returns `Result<void, CompilerError>` — errors are about mutation of frozen/global values
+  - Change to record errors on `fn.env` instead of accumulating internally
+  - **Key recovery strategy**: When a mutation of a frozen value is detected, record the error but treat the operation as a non-mutating read. This way downstream passes see a consistent (if conservative) view
+  - When a mutation of a global is detected, record the error but continue with the global unchanged
+  - Update Pipeline.ts (lines 233-239): remove the conditional `.isErr()` / throw pattern
+
+- [ ] **5.2 `inferMutationAliasingRanges`** (`src/Inference/InferMutationAliasingRanges.ts`)
+  - Currently returns `Result<Array<AliasingEffect>, CompilerError>`
+  - This pass has a meaningful success value (the function's external aliasing effects)
+  - Change to: always produce a best-effort effects array, record errors on env
+  - When errors are encountered, produce conservative effects (e.g., assume no external mutation)
+  - Update Pipeline.ts (lines 258-267): remove the conditional throw pattern, call directly
+
+### Phase 6: Update Codegen
+
+- [ ] **6.1 `codegenFunction`** (`src/ReactiveScopes/CodegenReactiveFunction.ts`)
+  - Currently returns `Result<CodegenFunction, CompilerError>`
+  - Change to: always produce a `CodegenFunction`, record errors on env
+  - If codegen encounters an error (e.g., an instruction it can't generate code for), it should:
+    - Record the error
+    - For `UnsupportedNode` values: pass through the original AST node (already works this way)
+    - For other error cases: emit a placeholder or the original AST where possible
+  - Update Pipeline.ts (line 575-578): remove `.unwrap()`
+
+### Phase 7: Pipeline.ts Pass-by-Pass Migration
+
+Walk through `runWithEnvironment` and wrap each pass call site. This is the integration work tying Phases 3-6 together.
+
+- [x] **7.1 Wrap `lower()` call** (line 163)
+  - Change from `lower(func, env).unwrap()` to `lower(func, env)` (direct return after Phase 3.1)
+
+- [x] **7.2 Wrap validation calls that use `.unwrap()`** (lines 169-303)
+  - Remove `.unwrap()` from all validation calls after they're updated in Phase 4
+  - For validations guarded by `env.enableValidations`, keep the guard but remove the `.unwrap()`
+
+- [x] **7.3 Wrap inference calls** (lines 233-267)
+  - After Phase 5, `inferMutationAliasingEffects` and `inferMutationAliasingRanges` record errors directly
+  - Remove the `mutabilityAliasingErrors` / `mutabilityAliasingRangeErrors` variables and their conditional throw logic
+
+- [x] **7.4 Wrap `env.logErrors()` calls** (lines 286-331)
+  - After Phase 4.13-4.16, these passes record on env directly
+  - Remove the `env.logErrors()` wrapper calls
+
+- [x] **7.5 Wrap codegen** (lines 575-578)
+  - After Phase 6.1, `codegenFunction` returns directly
+  - Remove the `.unwrap()`
+
+- [x] **7.6 Add final error check** (end of `runWithEnvironment`)
+  - After all passes complete, check `env.hasErrors()`
+  - If no errors: return `Ok(ast)`
+  - If errors: return `Err(env.aggregateErrors())`
+
+- [x] **7.7 Consider wrapping each pass in `env.tryRecord()`** as a safety net
+  - Even after individual passes are updated, wrapping each pass call in `env.tryRecord()` provides defense-in-depth
+  - If a pass unexpectedly throws a CompilerError (e.g., from a code path we missed), it gets caught and recorded rather than aborting the pipeline
+  - Non-CompilerError exceptions and invariants still propagate immediately
+
+### Phase 8: Testing
+
+- [ ] **8.1 Update existing `error.todo-*` fixture expectations**
+  - Currently, fixtures with `error.todo-` prefix expect a single error and bailout
+  - After fault tolerance, some of these may now produce multiple errors
+  - Update the `.expect.md` files to reflect the new aggregated error output
+
+- [ ] **8.2 Add multi-error test fixtures**
+  - Create test fixtures that contain multiple independent errors (e.g., both a `var` declaration and a mutation of a frozen value)
+  - Verify that all errors are reported, not just the first one
+
+- [ ] **8.3 Add test for invariant-still-throws behavior**
+  - Verify that `CompilerError.invariant()` failures still cause immediate abort
+  - Verify that non-CompilerError exceptions still cause immediate abort
+
+- [ ] **8.4 Add test for partial HIR codegen**
+  - Verify that when BuildHIR produces partial HIR (with `UnsupportedNode` values), later passes handle it gracefully and codegen produces the original AST for unsupported portions
+
+- [ ] **8.5 Verify error severity in aggregated output**
+  - Test that the aggregated `CompilerError` correctly reports `hasErrors()` vs `hasWarning()` vs `hasHints()` based on the mix of accumulated diagnostics
+  - Verify that `panicThreshold` behavior in Program.ts is correct for aggregated errors
+
+- [ ] **8.6 Run full test suite**
+  - Run `yarn snap` and `yarn snap -u` to update all fixture expectations
+  - Ensure no regressions in passing tests
+
+### Implementation Notes
+
+**Ordering**: Phases 1 → 2 → 3 → 4/5/6 (parallel) → 7 → 8. Phase 1 (Environment infrastructure) is the foundation. Phase 2 (Pipeline return type) sets up the contract. Phases 3-6 can be done incrementally — each pass can be migrated independently using `env.tryRecord()` as a transitional wrapper. Phase 7 is the integration. Phase 8 validates everything.
+
+**Incremental migration path**: Rather than updating all passes at once, each pass can be individually migrated. During the transition:
+1. First add `env.tryRecord()` in Phase 7.7 around all pass calls in the pipeline — this immediately provides fault tolerance by catching any thrown CompilerError
+2. Then individually update passes (Phases 3-6) to record errors directly on env, which is cleaner but not required for the basic behavior
+3. This means the feature can be landed incrementally: Phase 1 + 2 + 7.7 gives basic fault tolerance, then individual passes can be refined over time
+
+**What NOT to change**:
+- `CompilerError.invariant()` must continue to throw immediately — these represent internal bugs
+- Non-CompilerError exceptions must continue to throw — these are unexpected JS errors
+- The `assertConsistentIdentifiers`, `assertTerminalSuccessorsExist`, `assertTerminalPredsExist`, `assertValidBlockNesting`, `assertValidMutableRanges`, `assertWellFormedBreakTargets`, `assertScopeInstructionsWithinScopes` assertion functions should continue to throw — they are invariant checks on internal data structure consistency
+- The `panicThreshold` mechanism in Program.ts should continue to work — it now operates on the aggregated error from the Result rather than a caught exception, but the behavior is the same
+
+## Key Learnings
+
+* **Phase 2+7 (Pipeline tryRecord wrapping) was sufficient for basic fault tolerance.** Wrapping all passes in `env.tryRecord()` immediately enabled the compiler to continue past errors that previously threw. This caused 52 test fixtures to produce additional errors that were previously masked by the first error bailing out. For example, `error.todo-reassign-const` previously reported only "Support destructuring of context variables" but now also reports the immutability violation.
+* **Lint-only passes (Pattern B: `env.logErrors()`) should not use `tryRecord()`/`recordError()`** because those errors are intentionally non-blocking. They are reported via the logger only and should not cause the pipeline to return `Err`. The `logErrors` pattern was kept for `validateNoDerivedComputationsInEffects_exp`, `validateNoSetStateInEffects`, `validateNoJSXInTryStatement`, and `validateStaticComponents`.
+* **Inference passes that return `Result` with validation errors** (`inferMutationAliasingEffects`, `inferMutationAliasingRanges`) were changed to record errors via `env.recordErrors()` instead of throwing, allowing subsequent passes to proceed.
+* **Value-producing passes** (`memoizeFbtAndMacroOperandsInSameScope`, `renameVariables`, `buildReactiveFunction`) need safe default values when wrapped in `tryRecord()` since the callback can't return values. We initialize with empty defaults (e.g., `new Set()`) before the `tryRecord()` call.
+

compiler/packages/babel-plugin-react-compiler/docs/passes/README.md

@@ -302,15 +302,6 @@ yarn snap minimize <path>
 yarn snap -u
 ```
 
-## Fault Tolerance
-
-The pipeline is fault-tolerant: all passes run to completion, accumulating errors on `Environment` rather than aborting on the first error.
-
-- **Validation passes** are wrapped in `env.tryRecord()` in Pipeline.ts, which catches non-invariant `CompilerError`s and records them. If a validation pass throws, compilation continues.
-- **Infrastructure/transformation passes** (enterSSA, eliminateRedundantPhi, inferMutationAliasingEffects, codegen, etc.) are NOT wrapped in `tryRecord()` because subsequent passes depend on their output being structurally valid. If they fail, compilation aborts.
-- **`lower()` (BuildHIR)** always produces an `HIRFunction`, recording errors on `env` instead of returning `Err`. Unsupported constructs (e.g., `var`) are lowered best-effort.
-- At the end of the pipeline, `env.hasErrors()` determines whether to return `Ok(codegen)` or `Err(aggregatedErrors)`.
-
 ## Further Reading
 
 - [MUTABILITY_ALIASING_MODEL.md](../../src/Inference/MUTABILITY_ALIASING_MODEL.md): Detailed aliasing model docs

compiler/packages/babel-plugin-react-compiler/src/Entrypoint/Options.ts

@@ -252,7 +252,6 @@ export type LoggerEvent =
   | CompileErrorEvent
   | CompileDiagnosticEvent
   | CompileSkipEvent
-  | CompileUnexpectedThrowEvent
   | PipelineErrorEvent
   | TimingEvent;
 
@@ -287,11 +286,6 @@ export type PipelineErrorEvent = {
   fnLoc: t.SourceLocation | null;
   data: string;
 };
-export type CompileUnexpectedThrowEvent = {
-  kind: 'CompileUnexpectedThrow';
-  fnLoc: t.SourceLocation | null;
-  data: string;
-};
 export type TimingEvent = {
   kind: 'Timing';
   measurement: PerformanceMeasure;

compiler/packages/babel-plugin-react-compiler/src/Entrypoint/Pipeline.ts

@@ -13,6 +13,7 @@ import {CompilerError} from '../CompilerError';
 import {Err, Ok, Result} from '../Utils/Result';
 import {
   HIRFunction,
+  IdentifierId,
   ReactiveFunction,
   assertConsistentIdentifiers,
   assertTerminalPredsExist,
@@ -154,13 +155,15 @@ function runWithEnvironment(
   const log = (value: CompilerPipelineValue): void => {
     env.logger?.debugLogIRs?.(value);
   };
-  const hir = lower(func, env);
+  const hir = lower(func, env).unwrap();
   log({kind: 'hir', name: 'HIR', value: hir});
 
   pruneMaybeThrows(hir);
   log({kind: 'hir', name: 'PruneMaybeThrows', value: hir});
 
-  validateContextVariableLValues(hir);
+  env.tryRecord(() => {
+    validateContextVariableLValues(hir);
+  });
   validateUseMemo(hir);
 
   if (env.enableDropManualMemoization) {
@@ -210,8 +213,13 @@ function runWithEnvironment(
   analyseFunctions(hir);
   log({kind: 'hir', name: 'AnalyseFunctions', value: hir});
 
-  inferMutationAliasingEffects(hir);
+  const mutabilityAliasingErrors = inferMutationAliasingEffects(hir);
   log({kind: 'hir', name: 'InferMutationAliasingEffects', value: hir});
+  if (env.enableValidations) {
+    if (mutabilityAliasingErrors.isErr()) {
+      env.recordErrors(mutabilityAliasingErrors.unwrapErr());
+    }
+  }
 
   if (env.outputMode === 'ssr') {
     optimizeForSSR(hir);
@@ -224,13 +232,20 @@ function runWithEnvironment(
   pruneMaybeThrows(hir);
   log({kind: 'hir', name: 'PruneMaybeThrows', value: hir});
 
-  inferMutationAliasingRanges(hir, {
+  const mutabilityAliasingRangeErrors = inferMutationAliasingRanges(hir, {
     isFunctionExpression: false,
   });
   log({kind: 'hir', name: 'InferMutationAliasingRanges', value: hir});
   if (env.enableValidations) {
-    validateLocalsNotReassignedAfterRender(hir);
+    if (mutabilityAliasingRangeErrors.isErr()) {
+      env.recordErrors(mutabilityAliasingRangeErrors.unwrapErr());
+    }
+    env.tryRecord(() => {
+      validateLocalsNotReassignedAfterRender(hir);
+    });
+  }
 
+  if (env.enableValidations) {
     if (env.config.assertValidMutableRanges) {
       assertValidMutableRanges(hir);
     }
@@ -249,7 +264,9 @@ function runWithEnvironment(
     ) {
       env.logErrors(validateNoDerivedComputationsInEffects_exp(hir));
     } else if (env.config.validateNoDerivedComputationsInEffects) {
-      validateNoDerivedComputationsInEffects(hir);
+      env.tryRecord(() => {
+        validateNoDerivedComputationsInEffects(hir);
+      });
     }
 
     if (env.config.validateNoSetStateInEffects && env.outputMode === 'lint') {
@@ -260,7 +277,9 @@ function runWithEnvironment(
       env.logErrors(validateNoJSXInTryStatement(hir));
     }
 
-    validateNoFreezingKnownMutableFunctions(hir);
+    env.tryRecord(() => {
+      validateNoFreezingKnownMutableFunctions(hir);
+    });
   }
 
   inferReactivePlaces(hir);
@@ -301,7 +320,8 @@ function runWithEnvironment(
     log({kind: 'hir', name: 'InferReactiveScopeVariables', value: hir});
   }
 
-  const fbtOperands = memoizeFbtAndMacroOperandsInSameScope(hir);
+  let fbtOperands: Set<IdentifierId> = new Set();
+  fbtOperands = memoizeFbtAndMacroOperandsInSameScope(hir);
   log({
     kind: 'hir',
     name: 'MemoizeFbtAndMacroOperandsInSameScope',
@@ -386,7 +406,6 @@ function runWithEnvironment(
   });
   assertTerminalSuccessorsExist(hir);
   assertTerminalPredsExist(hir);
-
   propagateScopeDependenciesHIR(hir);
   log({
     kind: 'hir',
@@ -394,7 +413,8 @@ function runWithEnvironment(
     value: hir,
   });
 
-  const reactiveFunction = buildReactiveFunction(hir);
+  let reactiveFunction!: ReactiveFunction;
+  reactiveFunction = buildReactiveFunction(hir);
   log({
     kind: 'reactive',
     name: 'BuildReactiveFunction',
@@ -481,7 +501,8 @@ function runWithEnvironment(
     value: reactiveFunction,
   });
 
-  const uniqueIdentifiers = renameVariables(reactiveFunction);
+  let uniqueIdentifiers: Set<string> = new Set();
+  uniqueIdentifiers = renameVariables(reactiveFunction);
   log({
     kind: 'reactive',
     name: 'RenameVariables',
@@ -499,20 +520,29 @@ function runWithEnvironment(
     env.config.enablePreserveExistingMemoizationGuarantees ||
     env.config.validatePreserveExistingMemoizationGuarantees
   ) {
-    validatePreservedManualMemoization(reactiveFunction);
+    env.tryRecord(() => {
+      validatePreservedManualMemoization(reactiveFunction).unwrap();
+    });
   }
 
-  const ast = codegenFunction(reactiveFunction, {
+  const codegenResult = codegenFunction(reactiveFunction, {
     uniqueIdentifiers,
     fbtOperands,
   });
+  if (codegenResult.isErr()) {
+    env.recordErrors(codegenResult.unwrapErr());
+    return Err(env.aggregateErrors());
+  }
+  const ast = codegenResult.unwrap();
   log({kind: 'ast', name: 'Codegen', value: ast});
   for (const outlined of ast.outlined) {
     log({kind: 'ast', name: 'Codegen (outlined)', value: outlined.fn});
   }
 
   if (env.config.validateSourceLocations) {
-    validateSourceLocations(func, ast, env);
+    env.tryRecord(() => {
+      validateSourceLocations(func, ast).unwrap();
+    });
   }
 
   /**

compiler/packages/babel-plugin-react-compiler/src/Entrypoint/Program.ts

@@ -713,20 +713,6 @@ function tryCompileFunction(
       return {kind: 'error', error: result.unwrapErr()};
     }
   } catch (err) {
-    /**
-     * A pass incorrectly threw instead of recording the error.
-     * Log for detection in development.
-     */
-    if (
-      err instanceof CompilerError &&
-      err.details.every(detail => detail.category !== ErrorCategory.Invariant)
-    ) {
-      programContext.logEvent({
-        kind: 'CompileUnexpectedThrow',
-        fnLoc: fn.node.loc ?? null,
-        data: err.toString(),
-      });
-    }
     return {kind: 'error', error: err};
   }
 }

compiler/packages/babel-plugin-react-compiler/src/HIR/CollectOptionalChainDependencies.ts

@@ -310,13 +310,16 @@ function traverseOptionalBlock(
      * - a optional base block with a separate nested optional-chain (e.g. a(c?.d)?.d)
      */
     const testBlock = context.blocks.get(maybeTest.terminal.fallthrough)!;
-    /**
-     * Fallthrough of the inner optional should be a block with no
-     * instructions, terminating with Test($<temporary written to from
-     * StoreLocal>)
-     */
-    if (testBlock.terminal.kind !== 'branch') {
-      return null;
+    if (testBlock!.terminal.kind !== 'branch') {
+      /**
+       * Fallthrough of the inner optional should be a block with no
+       * instructions, terminating with Test($<temporary written to from
+       * StoreLocal>)
+       */
+      CompilerError.throwTodo({
+        reason: `Unexpected terminal kind \`${testBlock.terminal.kind}\` for optional fallthrough block`,
+        loc: maybeTest.terminal.loc,
+      });
     }
     /**
      * Recurse into inner optional blocks to collect inner optional-chain

compiler/packages/babel-plugin-react-compiler/src/HIR/Environment.ts

@@ -759,6 +759,29 @@ export class Environment {
     return this.#errors;
   }
 
+  /**
+   * Wraps a callback in try/catch: if the callback throws a CompilerError
+   * that is NOT an invariant, the error is recorded and execution continues.
+   * Non-CompilerError exceptions and invariants are re-thrown.
+   */
+  tryRecord(fn: () => void): void {
+    try {
+      fn();
+    } catch (err) {
+      if (err instanceof CompilerError) {
+        // Check if any detail is an invariant — if so, re-throw
+        for (const detail of err.details) {
+          if (detail.category === ErrorCategory.Invariant) {
+            throw err;
+          }
+        }
+        this.recordErrors(err);
+      } else {
+        throw err;
+      }
+    }
+  }
+
   isContextIdentifier(node: t.Identifier): boolean {
     return this.#contextIdentifiers.has(node);
   }
@@ -792,20 +815,18 @@ export class Environment {
        * NOTE: Zod doesn't work when specifying a function as a default, so we have to
        * fallback to the default value here
        */
-      const moduleTypeProvider = this.config.moduleTypeProvider;
-      if (
-        moduleTypeProvider != null &&
-        typeof moduleTypeProvider !== 'function'
-      ) {
+      const moduleTypeProvider =
+        this.config.moduleTypeProvider ?? defaultModuleTypeProvider;
+      if (moduleTypeProvider == null) {
+        return null;
+      }
+      if (typeof moduleTypeProvider !== 'function') {
         CompilerError.throwInvalidConfig({
           reason: `Expected a function for \`moduleTypeProvider\``,
           loc,
         });
       }
-      const unparsedModuleConfig =
-        (typeof moduleTypeProvider === 'function'
-          ? moduleTypeProvider(moduleName)
-          : null) ?? defaultModuleTypeProvider(moduleName);
+      const unparsedModuleConfig = moduleTypeProvider(moduleName);
       if (unparsedModuleConfig != null) {
         const parsedModuleConfig = TypeSchema.safeParse(unparsedModuleConfig);
         if (!parsedModuleConfig.success) {

compiler/packages/babel-plugin-react-compiler/src/HIR/Globals.ts

@@ -28,14 +28,6 @@ import {
   BuiltInWeakMapId,
   BuiltInWeakSetId,
   BuiltInEffectEventId,
-  BuiltInIntlDateTimeFormatId,
-  BuiltInIntlNumberFormatId,
-  BuiltInIntlCollatorId,
-  BuiltInIntlPluralRulesId,
-  BuiltInIntlListFormatId,
-  BuiltInIntlRelativeTimeFormatId,
-  BuiltInIntlSegmenterId,
-  BuiltInIntlDisplayNamesId,
   ReanimatedSharedValueId,
   ShapeRegistry,
   addFunction,
@@ -628,145 +620,6 @@ const TYPED_GLOBALS: Array<[string, BuiltInType]> = [
       true,
     ),
   ],
-  [
-    'Intl',
-    addObject(DEFAULT_SHAPES, 'Intl', [
-      [
-        'DateTimeFormat',
-        addFunction(
-          DEFAULT_SHAPES,
-          [],
-          {
-            positionalParams: [Effect.Read, Effect.Read],
-            restParam: null,
-            returnType: {
-              kind: 'Object',
-              shapeId: BuiltInIntlDateTimeFormatId,
-            },
-            calleeEffect: Effect.Read,
-            returnValueKind: ValueKind.Frozen,
-          },
-          null,
-          true,
-        ),
-      ],
-      [
-        'NumberFormat',
-        addFunction(
-          DEFAULT_SHAPES,
-          [],
-          {
-            positionalParams: [Effect.Read, Effect.Read],
-            restParam: null,
-            returnType: {kind: 'Object', shapeId: BuiltInIntlNumberFormatId},
-            calleeEffect: Effect.Read,
-            returnValueKind: ValueKind.Frozen,
-          },
-          null,
-          true,
-        ),
-      ],
-      [
-        'Collator',
-        addFunction(
-          DEFAULT_SHAPES,
-          [],
-          {
-            positionalParams: [Effect.Read, Effect.Read],
-            restParam: null,
-            returnType: {kind: 'Object', shapeId: BuiltInIntlCollatorId},
-            calleeEffect: Effect.Read,
-            returnValueKind: ValueKind.Frozen,
-          },
-          null,
-          true,
-        ),
-      ],
-      [
-        'PluralRules',
-        addFunction(
-          DEFAULT_SHAPES,
-          [],
-          {
-            positionalParams: [Effect.Read, Effect.Read],
-            restParam: null,
-            returnType: {kind: 'Object', shapeId: BuiltInIntlPluralRulesId},
-            calleeEffect: Effect.Read,
-            returnValueKind: ValueKind.Frozen,
-          },
-          null,
-          true,
-        ),
-      ],
-      [
-        'ListFormat',
-        addFunction(
-          DEFAULT_SHAPES,
-          [],
-          {
-            positionalParams: [Effect.Read, Effect.Read],
-            restParam: null,
-            returnType: {kind: 'Object', shapeId: BuiltInIntlListFormatId},
-            calleeEffect: Effect.Read,
-            returnValueKind: ValueKind.Frozen,
-          },
-          null,
-          true,
-        ),
-      ],
-      [
-        'RelativeTimeFormat',
-        addFunction(
-          DEFAULT_SHAPES,
-          [],
-          {
-            positionalParams: [Effect.Read, Effect.Read],
-            restParam: null,
-            returnType: {
-              kind: 'Object',
-              shapeId: BuiltInIntlRelativeTimeFormatId,
-            },
-            calleeEffect: Effect.Read,
-            returnValueKind: ValueKind.Frozen,
-          },
-          null,
-          true,
-        ),
-      ],
-      [
-        'Segmenter',
-        addFunction(
-          DEFAULT_SHAPES,
-          [],
-          {
-            positionalParams: [Effect.Read, Effect.Read],
-            restParam: null,
-            returnType: {kind: 'Object', shapeId: BuiltInIntlSegmenterId},
-            calleeEffect: Effect.Read,
-            returnValueKind: ValueKind.Frozen,
-          },
-          null,
-          true,
-        ),
-      ],
-      [
-        'DisplayNames',
-        addFunction(
-          DEFAULT_SHAPES,
-          [],
-          {
-            positionalParams: [Effect.Read, Effect.Read],
-            restParam: null,
-            returnType: {kind: 'Object', shapeId: BuiltInIntlDisplayNamesId},
-            calleeEffect: Effect.Read,
-            returnValueKind: ValueKind.Frozen,
-          },
-          null,
-          true,
-        ),
-      ],
-    ]),
-  ],
   // TODO: rest of Global objects
 ];
 

compiler/packages/babel-plugin-react-compiler/src/HIR/HIRBuilder.ts

@@ -7,12 +7,7 @@
 
 import {Binding, NodePath} from '@babel/traverse';
 import * as t from '@babel/types';
-import {
-  CompilerError,
-  CompilerDiagnostic,
-  CompilerErrorDetail,
-  ErrorCategory,
-} from '../CompilerError';
+import {CompilerError, ErrorCategory} from '../CompilerError';
 import {Environment} from './Environment';
 import {
   BasicBlock,
@@ -115,6 +110,7 @@ export default class HIRBuilder {
   #bindings: Bindings;
   #env: Environment;
   #exceptionHandlerStack: Array<BlockId> = [];
+  errors: CompilerError = new CompilerError();
   /**
    * Traversal context: counts the number of `fbt` tag parents
    * of the current babel node.
@@ -152,10 +148,6 @@ export default class HIRBuilder {
     this.#current = newBlock(this.#entry, options?.entryBlockKind ?? 'block');
   }
 
-  recordError(error: CompilerDiagnostic | CompilerErrorDetail): void {
-    this.#env.recordError(error);
-  }
-
   currentBlockKind(): BlockKind {
     return this.#current.kind;
   }
@@ -316,28 +308,34 @@ export default class HIRBuilder {
 
   resolveBinding(node: t.Identifier): Identifier {
     if (node.name === 'fbt') {
-      this.recordError(
-        new CompilerErrorDetail({
-          category: ErrorCategory.Todo,
-          reason: 'Support local variables named `fbt`',
-          description:
-            'Local variables named `fbt` may conflict with the fbt plugin and are not yet supported',
-          loc: node.loc ?? GeneratedSource,
-          suggestions: null,
-        }),
-      );
+      CompilerError.throwDiagnostic({
+        category: ErrorCategory.Todo,
+        reason: 'Support local variables named `fbt`',
+        description:
+          'Local variables named `fbt` may conflict with the fbt plugin and are not yet supported',
+        details: [
+          {
+            kind: 'error',
+            message: 'Rename to avoid conflict with fbt plugin',
+            loc: node.loc ?? GeneratedSource,
+          },
+        ],
+      });
     }
     if (node.name === 'this') {
-      this.recordError(
-        new CompilerErrorDetail({
-          category: ErrorCategory.UnsupportedSyntax,
-          reason: '`this` is not supported syntax',
-          description:
-            'React Compiler does not support compiling functions that use `this`',
-          loc: node.loc ?? GeneratedSource,
-          suggestions: null,
-        }),
-      );
+      CompilerError.throwDiagnostic({
+        category: ErrorCategory.UnsupportedSyntax,
+        reason: '`this` is not supported syntax',
+        description:
+          'React Compiler does not support compiling functions that use `this`',
+        details: [
+          {
+            kind: 'error',
+            message: '`this` was used here',
+            loc: node.loc ?? GeneratedSource,
+          },
+        ],
+      });
     }
     const originalName = node.name;
     let name = originalName;
@@ -383,15 +381,12 @@ export default class HIRBuilder {
           instr => instr.value.kind === 'FunctionExpression',
         )
       ) {
-        this.recordError(
-          new CompilerErrorDetail({
-            reason: `Support functions with unreachable code that may contain hoisted declarations`,
-            loc: block.instructions[0]?.loc ?? block.terminal.loc,
-            description: null,
-            suggestions: null,
-            category: ErrorCategory.Todo,
-          }),
-        );
+        CompilerError.throwTodo({
+          reason: `Support functions with unreachable code that may contain hoisted declarations`,
+          loc: block.instructions[0]?.loc ?? block.terminal.loc,
+          description: null,
+          suggestions: null,
+        });
       }
     }
     ir.blocks = rpoBlocks;

compiler/packages/babel-plugin-react-compiler/src/HIR/ObjectShape.ts

@@ -389,16 +389,6 @@ export const BuiltInEffectEventId = 'BuiltInEffectEventFunction';
 // See getReanimatedModuleType() in Globals.ts — this is part of supporting Reanimated's ref-like types
 export const ReanimatedSharedValueId = 'ReanimatedSharedValueId';
 
-// Intl formatter instance shapes
-export const BuiltInIntlDateTimeFormatId = 'BuiltInIntlDateTimeFormat';
-export const BuiltInIntlNumberFormatId = 'BuiltInIntlNumberFormat';
-export const BuiltInIntlCollatorId = 'BuiltInIntlCollator';
-export const BuiltInIntlPluralRulesId = 'BuiltInIntlPluralRules';
-export const BuiltInIntlListFormatId = 'BuiltInIntlListFormat';
-export const BuiltInIntlRelativeTimeFormatId = 'BuiltInIntlRelativeTimeFormat';
-export const BuiltInIntlSegmenterId = 'BuiltInIntlSegmenter';
-export const BuiltInIntlDisplayNamesId = 'BuiltInIntlDisplayNames';
-
 // ShapeRegistry with default definitions for built-ins.
 export const BUILTIN_SHAPES: ShapeRegistry = new Map();
 
@@ -1242,297 +1232,6 @@ addObject(BUILTIN_SHAPES, BuiltInRefValueId, [
 
 addObject(BUILTIN_SHAPES, ReanimatedSharedValueId, []);
 
-/**
- * Intl formatter instance shapes.
- *
- * All Intl formatter objects are immutable after construction — calling their
- * methods does not modify the formatter. Methods like `format()` return
- * primitives (strings/numbers), `formatToParts()` returns a new array, and
- * `resolvedOptions()` returns a new object.
- */
-
-/* Intl.DateTimeFormat instance */
-addObject(BUILTIN_SHAPES, BuiltInIntlDateTimeFormatId, [
-  [
-    'format',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [Effect.Read],
-      restParam: null,
-      returnType: {kind: 'Primitive'},
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Primitive,
-    }),
-  ],
-  [
-    'formatToParts',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [Effect.Read],
-      restParam: null,
-      returnType: {kind: 'Object', shapeId: BuiltInArrayId},
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Mutable,
-    }),
-  ],
-  [
-    'formatRange',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [Effect.Read, Effect.Read],
-      restParam: null,
-      returnType: {kind: 'Primitive'},
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Primitive,
-    }),
-  ],
-  [
-    'formatRangeToParts',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [Effect.Read, Effect.Read],
-      restParam: null,
-      returnType: {kind: 'Object', shapeId: BuiltInArrayId},
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Mutable,
-    }),
-  ],
-  [
-    'resolvedOptions',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [],
-      restParam: null,
-      returnType: {kind: 'Object', shapeId: BuiltInObjectId},
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Mutable,
-    }),
-  ],
-]);
-
-/* Intl.NumberFormat instance */
-addObject(BUILTIN_SHAPES, BuiltInIntlNumberFormatId, [
-  [
-    'format',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [Effect.Read],
-      restParam: null,
-      returnType: {kind: 'Primitive'},
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Primitive,
-    }),
-  ],
-  [
-    'formatToParts',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [Effect.Read],
-      restParam: null,
-      returnType: {kind: 'Object', shapeId: BuiltInArrayId},
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Mutable,
-    }),
-  ],
-  [
-    'formatRange',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [Effect.Read, Effect.Read],
-      restParam: null,
-      returnType: {kind: 'Primitive'},
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Primitive,
-    }),
-  ],
-  [
-    'formatRangeToParts',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [Effect.Read, Effect.Read],
-      restParam: null,
-      returnType: {kind: 'Object', shapeId: BuiltInArrayId},
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Mutable,
-    }),
-  ],
-  [
-    'resolvedOptions',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [],
-      restParam: null,
-      returnType: {kind: 'Object', shapeId: BuiltInObjectId},
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Mutable,
-    }),
-  ],
-]);
-
-/* Intl.Collator instance */
-addObject(BUILTIN_SHAPES, BuiltInIntlCollatorId, [
-  [
-    'compare',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [Effect.Read, Effect.Read],
-      restParam: null,
-      returnType: {kind: 'Primitive'},
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Primitive,
-    }),
-  ],
-  [
-    'resolvedOptions',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [],
-      restParam: null,
-      returnType: {kind: 'Object', shapeId: BuiltInObjectId},
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Mutable,
-    }),
-  ],
-]);
-
-/* Intl.PluralRules instance */
-addObject(BUILTIN_SHAPES, BuiltInIntlPluralRulesId, [
-  [
-    'select',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [Effect.Read],
-      restParam: null,
-      returnType: {kind: 'Primitive'},
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Primitive,
-    }),
-  ],
-  [
-    'selectRange',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [Effect.Read, Effect.Read],
-      restParam: null,
-      returnType: {kind: 'Primitive'},
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Primitive,
-    }),
-  ],
-  [
-    'resolvedOptions',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [],
-      restParam: null,
-      returnType: {kind: 'Object', shapeId: BuiltInObjectId},
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Mutable,
-    }),
-  ],
-]);
-
-/* Intl.ListFormat instance */
-addObject(BUILTIN_SHAPES, BuiltInIntlListFormatId, [
-  [
-    'format',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [Effect.Read],
-      restParam: null,
-      returnType: {kind: 'Primitive'},
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Primitive,
-    }),
-  ],
-  [
-    'formatToParts',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [Effect.Read],
-      restParam: null,
-      returnType: {kind: 'Object', shapeId: BuiltInArrayId},
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Mutable,
-    }),
-  ],
-  [
-    'resolvedOptions',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [],
-      restParam: null,
-      returnType: {kind: 'Object', shapeId: BuiltInObjectId},
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Mutable,
-    }),
-  ],
-]);
-
-/* Intl.RelativeTimeFormat instance */
-addObject(BUILTIN_SHAPES, BuiltInIntlRelativeTimeFormatId, [
-  [
-    'format',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [Effect.Read, Effect.Read],
-      restParam: null,
-      returnType: {kind: 'Primitive'},
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Primitive,
-    }),
-  ],
-  [
-    'formatToParts',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [Effect.Read, Effect.Read],
-      restParam: null,
-      returnType: {kind: 'Object', shapeId: BuiltInArrayId},
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Mutable,
-    }),
-  ],
-  [
-    'resolvedOptions',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [],
-      restParam: null,
-      returnType: {kind: 'Object', shapeId: BuiltInObjectId},
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Mutable,
-    }),
-  ],
-]);
-
-/* Intl.Segmenter instance */
-addObject(BUILTIN_SHAPES, BuiltInIntlSegmenterId, [
-  [
-    'segment',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [Effect.Read],
-      restParam: null,
-      returnType: {kind: 'Poly'},
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Mutable,
-    }),
-  ],
-  [
-    'resolvedOptions',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [],
-      restParam: null,
-      returnType: {kind: 'Object', shapeId: BuiltInObjectId},
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Mutable,
-    }),
-  ],
-]);
-
-/* Intl.DisplayNames instance */
-addObject(BUILTIN_SHAPES, BuiltInIntlDisplayNamesId, [
-  [
-    'of',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [Effect.Read],
-      restParam: null,
-      returnType: {kind: 'Primitive'},
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Primitive,
-    }),
-  ],
-  [
-    'resolvedOptions',
-    addFunction(BUILTIN_SHAPES, [], {
-      positionalParams: [],
-      restParam: null,
-      returnType: {kind: 'Object', shapeId: BuiltInObjectId},
-      calleeEffect: Effect.Read,
-      returnValueKind: ValueKind.Mutable,
-    }),
-  ],
-]);
-
 addFunction(
   BUILTIN_SHAPES,
   [],

compiler/packages/babel-plugin-react-compiler/src/Inference/AnalyseFunctions.ts

@@ -54,7 +54,7 @@ function lowerWithMutationAliasing(fn: HIRFunction): void {
   deadCodeElimination(fn);
   const functionEffects = inferMutationAliasingRanges(fn, {
     isFunctionExpression: true,
-  });
+  }).unwrap();
   rewriteInstructionKindsBasedOnReassignment(fn);
   inferReactiveScopeVariables(fn);
   fn.aliasingEffects = functionEffects;

compiler/packages/babel-plugin-react-compiler/src/Inference/DropManualMemoization.ts

@@ -293,7 +293,7 @@ function extractManualMemoizationArgs(
   instr: TInstruction<CallExpression> | TInstruction<MethodCall>,
   kind: 'useCallback' | 'useMemo',
   sidemap: IdentifierSidemap,
-  env: Environment,
+  errors: CompilerError,
 ): {
   fnPlace: Place;
   depsList: Array<ManualMemoDependency> | null;
@@ -303,7 +303,7 @@ function extractManualMemoizationArgs(
     Place | SpreadPattern | undefined
   >;
   if (fnPlace == null || fnPlace.kind !== 'Identifier') {
-    env.recordError(
+    errors.pushDiagnostic(
       CompilerDiagnostic.create({
         category: ErrorCategory.UseMemo,
         reason: `Expected a callback function to be passed to ${kind}`,
@@ -335,7 +335,7 @@ function extractManualMemoizationArgs(
       ? sidemap.maybeDepsLists.get(depsListPlace.identifier.id)
       : null;
   if (maybeDepsList == null) {
-    env.recordError(
+    errors.pushDiagnostic(
       CompilerDiagnostic.create({
         category: ErrorCategory.UseMemo,
         reason: `Expected the dependency list for ${kind} to be an array literal`,
@@ -354,7 +354,7 @@ function extractManualMemoizationArgs(
   for (const dep of maybeDepsList.deps) {
     const maybeDep = sidemap.maybeDeps.get(dep.identifier.id);
     if (maybeDep == null) {
-      env.recordError(
+      errors.pushDiagnostic(
         CompilerDiagnostic.create({
           category: ErrorCategory.UseMemo,
           reason: `Expected the dependency list to be an array of simple expressions (e.g. \`x\`, \`x.y.z\`, \`x?.y?.z\`)`,
@@ -389,6 +389,7 @@ function extractManualMemoizationArgs(
  * is only used for memoizing values and not for running arbitrary side effects.
  */
 export function dropManualMemoization(func: HIRFunction): void {
+  const errors = new CompilerError();
   const isValidationEnabled =
     func.env.config.validatePreserveExistingMemoizationGuarantees ||
     func.env.config.validateNoSetStateInRender ||
@@ -435,7 +436,7 @@ export function dropManualMemoization(func: HIRFunction): void {
             instr as TInstruction<CallExpression> | TInstruction<MethodCall>,
             manualMemo.kind,
             sidemap,
-            func.env,
+            errors,
           );
 
           if (memoDetails == null) {
@@ -463,7 +464,7 @@ export function dropManualMemoization(func: HIRFunction): void {
              * is rare and likely sketchy.
              */
             if (!sidemap.functions.has(fnPlace.identifier.id)) {
-              func.env.recordError(
+              errors.pushDiagnostic(
                 CompilerDiagnostic.create({
                   category: ErrorCategory.UseMemo,
                   reason: `Expected the first argument to be an inline function expression`,
@@ -548,6 +549,10 @@ export function dropManualMemoization(func: HIRFunction): void {
       markInstructionIds(func.body);
     }
   }
+
+  if (errors.hasAnyErrors()) {
+    func.env.recordErrors(errors);
+  }
 }
 
 function findOptionalPlaces(fn: HIRFunction): Set<IdentifierId> {

compiler/packages/babel-plugin-react-compiler/src/Inference/InferMutationAliasingEffects.ts

@@ -45,7 +45,7 @@ import {
   eachTerminalOperand,
   eachTerminalSuccessor,
 } from '../HIR/visitors';
-
+import {Ok, Result} from '../Utils/Result';
 import {
   assertExhaustive,
   getOrInsertDefault,
@@ -100,7 +100,7 @@ export function inferMutationAliasingEffects(
   {isFunctionExpression}: {isFunctionExpression: boolean} = {
     isFunctionExpression: false,
   },
-): void {
+): Result<void, CompilerError> {
   const initialState = InferenceState.empty(fn.env, isFunctionExpression);
 
   // Map of blocks to the last (merged) incoming state that was processed
@@ -220,7 +220,7 @@ export function inferMutationAliasingEffects(
       }
     }
   }
-  return;
+  return Ok(undefined);
 }
 
 function findHoistedContextDeclarations(

compiler/packages/babel-plugin-react-compiler/src/Inference/InferMutationAliasingRanges.ts

@@ -20,14 +20,13 @@ import {
   Place,
   isPrimitiveType,
 } from '../HIR/HIR';
-import {Environment} from '../HIR/Environment';
 import {
   eachInstructionLValue,
   eachInstructionValueOperand,
   eachTerminalOperand,
 } from '../HIR/visitors';
 import {assertExhaustive, getOrInsertWith} from '../Utils/utils';
-
+import {Err, Ok, Result} from '../Utils/Result';
 import {AliasingEffect, MutationReason} from './AliasingEffects';
 
 /**
@@ -75,7 +74,7 @@ import {AliasingEffect, MutationReason} from './AliasingEffects';
 export function inferMutationAliasingRanges(
   fn: HIRFunction,
   {isFunctionExpression}: {isFunctionExpression: boolean},
-): Array<AliasingEffect> {
+): Result<Array<AliasingEffect>, CompilerError> {
   // The set of externally-visible effects
   const functionEffects: Array<AliasingEffect> = [];
 
@@ -108,7 +107,7 @@ export function inferMutationAliasingRanges(
 
   let index = 0;
 
-  const shouldRecordErrors = !isFunctionExpression && fn.env.enableValidations;
+  const errors = new CompilerError();
 
   for (const param of [...fn.params, ...fn.context, fn.returns]) {
     const place = param.kind === 'Identifier' ? param : param.place;
@@ -201,9 +200,7 @@ export function inferMutationAliasingRanges(
           effect.kind === 'MutateGlobal' ||
           effect.kind === 'Impure'
         ) {
-          if (shouldRecordErrors) {
-            fn.env.recordError(effect.error);
-          }
+          errors.pushDiagnostic(effect.error);
           functionEffects.push(effect);
         } else if (effect.kind === 'Render') {
           renders.push({index: index++, place: effect.place});
@@ -248,15 +245,11 @@ export function inferMutationAliasingRanges(
       mutation.kind,
       mutation.place.loc,
       mutation.reason,
-      shouldRecordErrors ? fn.env : null,
+      errors,
     );
   }
   for (const render of renders) {
-    state.render(
-      render.index,
-      render.place.identifier,
-      shouldRecordErrors ? fn.env : null,
-    );
+    state.render(render.index, render.place.identifier, errors);
   }
   for (const param of [...fn.context, ...fn.params]) {
     const place = param.kind === 'Identifier' ? param : param.place;
@@ -505,6 +498,7 @@ export function inferMutationAliasingRanges(
    * would be transitively mutated needs a capture relationship.
    */
   const tracked: Array<Place> = [];
+  const ignoredErrors = new CompilerError();
   for (const param of [...fn.params, ...fn.context, fn.returns]) {
     const place = param.kind === 'Identifier' ? param : param.place;
     tracked.push(place);
@@ -519,7 +513,7 @@ export function inferMutationAliasingRanges(
       MutationKind.Conditional,
       into.loc,
       null,
-      null,
+      ignoredErrors,
     );
     for (const from of tracked) {
       if (
@@ -553,17 +547,19 @@ export function inferMutationAliasingRanges(
     }
   }
 
-  return functionEffects;
+  if (errors.hasAnyErrors() && !isFunctionExpression) {
+    return Err(errors);
+  }
+  return Ok(functionEffects);
 }
 
-function appendFunctionErrors(env: Environment | null, fn: HIRFunction): void {
-  if (env == null) return;
+function appendFunctionErrors(errors: CompilerError, fn: HIRFunction): void {
   for (const effect of fn.aliasingEffects ?? []) {
     switch (effect.kind) {
       case 'Impure':
       case 'MutateFrozen':
       case 'MutateGlobal': {
-        env.recordError(effect.error);
+        errors.pushDiagnostic(effect.error);
         break;
       }
     }
@@ -664,7 +660,7 @@ class AliasingState {
     }
   }
 
-  render(index: number, start: Identifier, env: Environment | null): void {
+  render(index: number, start: Identifier, errors: CompilerError): void {
     const seen = new Set<Identifier>();
     const queue: Array<Identifier> = [start];
     while (queue.length !== 0) {
@@ -678,7 +674,7 @@ class AliasingState {
         continue;
       }
       if (node.value.kind === 'Function') {
-        appendFunctionErrors(env, node.value.function);
+        appendFunctionErrors(errors, node.value.function);
       }
       for (const [alias, when] of node.createdFrom) {
         if (when >= index) {
@@ -710,7 +706,7 @@ class AliasingState {
     startKind: MutationKind,
     loc: SourceLocation,
     reason: MutationReason | null,
-    env: Environment | null,
+    errors: CompilerError,
   ): void {
     const seen = new Map<Identifier, MutationKind>();
     const queue: Array<{
@@ -742,7 +738,7 @@ class AliasingState {
         node.transitive == null &&
         node.local == null
       ) {
-        appendFunctionErrors(env, node.value.function);
+        appendFunctionErrors(errors, node.value.function);
       }
       if (transitive) {
         if (node.transitive == null || node.transitive.kind < kind) {

compiler/packages/babel-plugin-react-compiler/src/ReactiveScopes/BuildReactiveFunction.ts

@@ -1007,10 +1007,11 @@ class Driver {
     const test = this.visitValueBlock(testBlockId, loc);
     const testBlock = this.cx.ir.blocks.get(test.block)!;
     if (testBlock.terminal.kind !== 'branch') {
-      CompilerError.invariant(false, {
-        reason: `Expected a branch terminal for ${terminalKind} test block`,
-        description: `Got \`${testBlock.terminal.kind}\``,
+      CompilerError.throwTodo({
+        reason: `Unexpected terminal kind \`${testBlock.terminal.kind}\` for ${terminalKind} test block`,
+        description: null,
         loc: testBlock.terminal.loc,
+        suggestions: null,
       });
     }
     return {

compiler/packages/babel-plugin-react-compiler/src/ReactiveScopes/CodegenReactiveFunction.ts

@@ -13,11 +13,7 @@ import {
   pruneUnusedLabels,
   renameVariables,
 } from '.';
-import {
-  CompilerError,
-  CompilerErrorDetail,
-  ErrorCategory,
-} from '../CompilerError';
+import {CompilerError, ErrorCategory} from '../CompilerError';
 import {Environment, ExternalFunction} from '../HIR';
 import {
   ArrayPattern,
@@ -50,7 +46,7 @@ import {
 } from '../HIR/HIR';
 import {printIdentifier, printInstruction, printPlace} from '../HIR/PrintHIR';
 import {eachPatternOperand} from '../HIR/visitors';
-
+import {Err, Ok, Result} from '../Utils/Result';
 import {GuardKind} from '../Utils/RuntimeDiagnosticConstants';
 import {assertExhaustive} from '../Utils/utils';
 import {buildReactiveFunction} from './BuildReactiveFunction';
@@ -115,7 +111,7 @@ export function codegenFunction(
     uniqueIdentifiers: Set<string>;
     fbtOperands: Set<IdentifierId>;
   },
-): CodegenFunction {
+): Result<CodegenFunction, CompilerError> {
   const cx = new Context(
     fn.env,
     fn.id ?? '[[ anonymous ]]',
@@ -145,7 +141,11 @@ export function codegenFunction(
     };
   }
 
-  const compiled = codegenReactiveFunction(cx, fn);
+  const compileResult = codegenReactiveFunction(cx, fn);
+  if (compileResult.isErr()) {
+    return compileResult;
+  }
+  const compiled = compileResult.unwrap();
 
   const hookGuard = fn.env.config.enableEmitHookGuards;
   if (hookGuard != null && fn.env.outputMode === 'client') {
@@ -273,7 +273,7 @@ export function codegenFunction(
         emitInstrumentForget.globalGating,
       );
       if (assertResult.isErr()) {
-        fn.env.recordErrors(assertResult.unwrapErr());
+        return assertResult;
       }
     }
 
@@ -323,17 +323,20 @@ export function codegenFunction(
       ),
       reactiveFunction,
     );
-    outlined.push({fn: codegen, type});
+    if (codegen.isErr()) {
+      return codegen;
+    }
+    outlined.push({fn: codegen.unwrap(), type});
   }
   compiled.outlined = outlined;
 
-  return compiled;
+  return compileResult;
 }
 
 function codegenReactiveFunction(
   cx: Context,
   fn: ReactiveFunction,
-): CodegenFunction {
+): Result<CodegenFunction, CompilerError> {
   for (const param of fn.params) {
     const place = param.kind === 'Identifier' ? param : param.place;
     cx.temp.set(place.identifier.declarationId, null);
@@ -351,10 +354,14 @@ function codegenReactiveFunction(
     }
   }
 
+  if (cx.errors.hasAnyErrors()) {
+    return Err(cx.errors);
+  }
+
   const countMemoBlockVisitor = new CountMemoBlockVisitor(fn.env);
   visitReactiveFunction(fn, countMemoBlockVisitor, undefined);
 
-  return {
+  return Ok({
     type: 'CodegenFunction',
     loc: fn.loc,
     id: fn.id !== null ? t.identifier(fn.id) : null,
@@ -369,7 +376,7 @@ function codegenReactiveFunction(
     prunedMemoBlocks: countMemoBlockVisitor.prunedMemoBlocks,
     prunedMemoValues: countMemoBlockVisitor.prunedMemoValues,
     outlined: [],
-  };
+  });
 }
 
 class CountMemoBlockVisitor extends ReactiveFunctionVisitor<void> {
@@ -420,6 +427,7 @@ class Context {
    */
   #declarations: Set<DeclarationId> = new Set();
   temp: Temporaries;
+  errors: CompilerError = new CompilerError();
   objectMethods: Map<IdentifierId, ObjectMethod> = new Map();
   uniqueIdentifiers: Set<string>;
   fbtOperands: Set<IdentifierId>;
@@ -438,11 +446,6 @@ class Context {
     this.fbtOperands = fbtOperands;
     this.temp = temporaries !== null ? new Map(temporaries) : new Map();
   }
-
-  recordError(error: CompilerErrorDetail): void {
-    this.env.recordError(error);
-  }
-
   get nextCacheIndex(): number {
     return this.#nextCacheIndex++;
   }
@@ -779,15 +782,12 @@ function codegenTerminal(
         loc: terminal.init.loc,
       });
       if (terminal.init.instructions.length !== 2) {
-        cx.recordError(
-          new CompilerErrorDetail({
-            reason: 'Support non-trivial for..in inits',
-            category: ErrorCategory.Todo,
-            loc: terminal.init.loc,
-            suggestions: null,
-          }),
-        );
-        return t.emptyStatement();
+        CompilerError.throwTodo({
+          reason: 'Support non-trivial for..in inits',
+          description: null,
+          loc: terminal.init.loc,
+          suggestions: null,
+        });
       }
       const iterableCollection = terminal.init.instructions[0];
       const iterableItem = terminal.init.instructions[1];
@@ -802,15 +802,12 @@ function codegenTerminal(
           break;
         }
         case 'StoreContext': {
-          cx.recordError(
-            new CompilerErrorDetail({
-              reason: 'Support non-trivial for..in inits',
-              category: ErrorCategory.Todo,
-              loc: terminal.init.loc,
-              suggestions: null,
-            }),
-          );
-          return t.emptyStatement();
+          CompilerError.throwTodo({
+            reason: 'Support non-trivial for..in inits',
+            description: null,
+            loc: terminal.init.loc,
+            suggestions: null,
+          });
         }
         default:
           CompilerError.invariant(false, {
@@ -880,15 +877,12 @@ function codegenTerminal(
         loc: terminal.test.loc,
       });
       if (terminal.test.instructions.length !== 2) {
-        cx.recordError(
-          new CompilerErrorDetail({
-            reason: 'Support non-trivial for..of inits',
-            category: ErrorCategory.Todo,
-            loc: terminal.init.loc,
-            suggestions: null,
-          }),
-        );
-        return t.emptyStatement();
+        CompilerError.throwTodo({
+          reason: 'Support non-trivial for..of inits',
+          description: null,
+          loc: terminal.init.loc,
+          suggestions: null,
+        });
       }
       const iterableItem = terminal.test.instructions[1];
       let lval: t.LVal;
@@ -902,15 +896,12 @@ function codegenTerminal(
           break;
         }
         case 'StoreContext': {
-          cx.recordError(
-            new CompilerErrorDetail({
-              reason: 'Support non-trivial for..of inits',
-              category: ErrorCategory.Todo,
-              loc: terminal.init.loc,
-              suggestions: null,
-            }),
-          );
-          return t.emptyStatement();
+          CompilerError.throwTodo({
+            reason: 'Support non-trivial for..of inits',
+            description: null,
+            loc: terminal.init.loc,
+            suggestions: null,
+          });
         }
         default:
           CompilerError.invariant(false, {
@@ -1674,7 +1665,7 @@ function codegenInstructionValue(
                   cx.temp,
                 ),
                 reactiveFunction,
-              );
+              ).unwrap();
 
               /*
                * ObjectMethod builder must be backwards compatible with older versions of babel.
@@ -1873,7 +1864,7 @@ function codegenInstructionValue(
           cx.temp,
         ),
         reactiveFunction,
-      );
+      ).unwrap();
 
       if (instrValue.type === 'ArrowFunctionExpression') {
         let body: t.BlockStatement | t.Expression = fn.body;
@@ -1969,26 +1960,22 @@ function codegenInstructionValue(
         } else {
           if (t.isVariableDeclaration(stmt)) {
             const declarator = stmt.declarations[0];
-            cx.recordError(
-              new CompilerErrorDetail({
-                reason: `(CodegenReactiveFunction::codegenInstructionValue) Cannot declare variables in a value block, tried to declare '${
-                  (declarator.id as t.Identifier).name
-                }'`,
-                category: ErrorCategory.Todo,
-                loc: declarator.loc ?? null,
-                suggestions: null,
-              }),
-            );
+            cx.errors.push({
+              reason: `(CodegenReactiveFunction::codegenInstructionValue) Cannot declare variables in a value block, tried to declare '${
+                (declarator.id as t.Identifier).name
+              }'`,
+              category: ErrorCategory.Todo,
+              loc: declarator.loc ?? null,
+              suggestions: null,
+            });
             return t.stringLiteral(`TODO handle ${declarator.id}`);
           } else {
-            cx.recordError(
-              new CompilerErrorDetail({
-                reason: `(CodegenReactiveFunction::codegenInstructionValue) Handle conversion of ${stmt.type} to expression`,
-                category: ErrorCategory.Todo,
-                loc: stmt.loc ?? null,
-                suggestions: null,
-              }),
-            );
+            cx.errors.push({
+              reason: `(CodegenReactiveFunction::codegenInstructionValue) Handle conversion of ${stmt.type} to expression`,
+              category: ErrorCategory.Todo,
+              loc: stmt.loc ?? null,
+              suggestions: null,
+            });
             return t.stringLiteral(`TODO handle ${stmt.type}`);
           }
         }

compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateContextVariableLValues.ts

@@ -5,9 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import {CompilerDiagnostic, CompilerError} from '..';
-import {ErrorCategory} from '../CompilerError';
-import {Environment} from '../HIR/Environment';
+import {CompilerError} from '..';
 import {HIRFunction, IdentifierId, Place} from '../HIR';
 import {printPlace} from '../HIR/PrintHIR';
 import {eachInstructionValueLValue, eachPatternOperand} from '../HIR/visitors';
@@ -19,13 +17,12 @@ import {eachInstructionValueLValue, eachPatternOperand} from '../HIR/visitors';
  */
 export function validateContextVariableLValues(fn: HIRFunction): void {
   const identifierKinds: IdentifierKinds = new Map();
-  validateContextVariableLValuesImpl(fn, identifierKinds, fn.env);
+  validateContextVariableLValuesImpl(fn, identifierKinds);
 }
 
 function validateContextVariableLValuesImpl(
   fn: HIRFunction,
   identifierKinds: IdentifierKinds,
-  env: Environment,
 ): void {
   for (const [, block] of fn.body.blocks) {
     for (const instr of block.instructions) {
@@ -33,30 +30,30 @@ function validateContextVariableLValuesImpl(
       switch (value.kind) {
         case 'DeclareContext':
         case 'StoreContext': {
-          visit(identifierKinds, value.lvalue.place, 'context', env);
+          visit(identifierKinds, value.lvalue.place, 'context');
           break;
         }
         case 'LoadContext': {
-          visit(identifierKinds, value.place, 'context', env);
+          visit(identifierKinds, value.place, 'context');
           break;
         }
         case 'StoreLocal':
         case 'DeclareLocal': {
-          visit(identifierKinds, value.lvalue.place, 'local', env);
+          visit(identifierKinds, value.lvalue.place, 'local');
           break;
         }
         case 'LoadLocal': {
-          visit(identifierKinds, value.place, 'local', env);
+          visit(identifierKinds, value.place, 'local');
           break;
         }
         case 'PostfixUpdate':
         case 'PrefixUpdate': {
-          visit(identifierKinds, value.lvalue, 'local', env);
+          visit(identifierKinds, value.lvalue, 'local');
           break;
         }
         case 'Destructure': {
           for (const lvalue of eachPatternOperand(value.lvalue.pattern)) {
-            visit(identifierKinds, lvalue, 'destructure', env);
+            visit(identifierKinds, lvalue, 'destructure');
           }
           break;
         }
@@ -65,24 +62,18 @@ function validateContextVariableLValuesImpl(
           validateContextVariableLValuesImpl(
             value.loweredFunc.func,
             identifierKinds,
-            env,
           );
           break;
         }
         default: {
           for (const _ of eachInstructionValueLValue(value)) {
-            fn.env.recordError(
-              CompilerDiagnostic.create({
-                category: ErrorCategory.Todo,
-                reason:
-                  'ValidateContextVariableLValues: unhandled instruction variant',
-                description: `Handle '${value.kind} lvalues`,
-              }).withDetails({
-                kind: 'error',
-                loc: value.loc,
-                message: null,
-              }),
-            );
+            CompilerError.throwTodo({
+              reason:
+                'ValidateContextVariableLValues: unhandled instruction variant',
+              loc: value.loc,
+              description: `Handle '${value.kind} lvalues`,
+              suggestions: null,
+            });
           }
         }
       }
@@ -99,7 +90,6 @@ function visit(
   identifiers: IdentifierKinds,
   place: Place,
   kind: 'local' | 'context' | 'destructure',
-  env: Environment,
 ): void {
   const prev = identifiers.get(place.identifier.id);
   if (prev !== undefined) {
@@ -107,18 +97,12 @@ function visit(
     const isContext = kind === 'context';
     if (wasContext !== isContext) {
       if (prev.kind === 'destructure' || kind === 'destructure') {
-        env.recordError(
-          CompilerDiagnostic.create({
-            category: ErrorCategory.Todo,
-            reason: `Support destructuring of context variables`,
-            description: null,
-          }).withDetails({
-            kind: 'error',
-            loc: kind === 'destructure' ? place.loc : prev.place.loc,
-            message: null,
-          }),
-        );
-        return;
+        CompilerError.throwTodo({
+          reason: `Support destructuring of context variables`,
+          loc: kind === 'destructure' ? place.loc : prev.place.loc,
+          description: null,
+          suggestions: null,
+        });
       }
 
       CompilerError.invariant(false, {

compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateExhaustiveDependencies.ts

@@ -102,6 +102,7 @@ export function validateExhaustiveDependencies(fn: HIRFunction): void {
       loc: place.loc,
     });
   }
+  const error = new CompilerError();
   let startMemo: StartMemoize | null = null;
 
   function onStartMemoize(
@@ -142,7 +143,7 @@ export function validateExhaustiveDependencies(fn: HIRFunction): void {
         'all',
       );
       if (diagnostic != null) {
-        fn.env.recordError(diagnostic);
+        error.pushDiagnostic(diagnostic);
       }
     }
 
@@ -207,12 +208,15 @@ export function validateExhaustiveDependencies(fn: HIRFunction): void {
           effectReportMode,
         );
         if (diagnostic != null) {
-          fn.env.recordError(diagnostic);
+          error.pushDiagnostic(diagnostic);
         }
       },
     },
     false, // isFunctionExpression
   );
+  if (error.hasAnyErrors()) {
+    fn.env.recordErrors(error);
+  }
 }
 
 function validateDependencies(

compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateHooksUsage.ts

@@ -6,9 +6,13 @@
  */
 
 import * as t from '@babel/types';
-import {CompilerErrorDetail, ErrorCategory} from '../CompilerError';
+import {
+  CompilerError,
+  CompilerErrorDetail,
+  ErrorCategory,
+} from '../CompilerError';
 import {computeUnconditionalBlocks} from '../HIR/ComputeUnconditionalBlocks';
-import {Environment, isHookName} from '../HIR/Environment';
+import {isHookName} from '../HIR/Environment';
 import {
   HIRFunction,
   IdentifierId,
@@ -86,14 +90,15 @@ function joinKinds(a: Kind, b: Kind): Kind {
 export function validateHooksUsage(fn: HIRFunction): void {
   const unconditionalBlocks = computeUnconditionalBlocks(fn);
 
+  const errors = new CompilerError();
   const errorsByPlace = new Map<t.SourceLocation, CompilerErrorDetail>();
 
-  function trackError(
+  function recordError(
     loc: SourceLocation,
     errorDetail: CompilerErrorDetail,
   ): void {
     if (typeof loc === 'symbol') {
-      fn.env.recordError(errorDetail);
+      errors.pushErrorDetail(errorDetail);
     } else {
       errorsByPlace.set(loc, errorDetail);
     }
@@ -113,7 +118,7 @@ export function validateHooksUsage(fn: HIRFunction): void {
      * If that same place is also used as a conditional call, upgrade the error to a conditonal hook error
      */
     if (previousError === undefined || previousError.reason !== reason) {
-      trackError(
+      recordError(
         place.loc,
         new CompilerErrorDetail({
           category: ErrorCategory.Hooks,
@@ -129,7 +134,7 @@ export function validateHooksUsage(fn: HIRFunction): void {
     const previousError =
       typeof place.loc !== 'symbol' ? errorsByPlace.get(place.loc) : undefined;
     if (previousError === undefined) {
-      trackError(
+      recordError(
         place.loc,
         new CompilerErrorDetail({
           category: ErrorCategory.Hooks,
@@ -146,7 +151,7 @@ export function validateHooksUsage(fn: HIRFunction): void {
     const previousError =
       typeof place.loc !== 'symbol' ? errorsByPlace.get(place.loc) : undefined;
     if (previousError === undefined) {
-      trackError(
+      recordError(
         place.loc,
         new CompilerErrorDetail({
           category: ErrorCategory.Hooks,
@@ -391,7 +396,7 @@ export function validateHooksUsage(fn: HIRFunction): void {
         }
         case 'ObjectMethod':
         case 'FunctionExpression': {
-          visitFunctionExpression(fn.env, instr.value.loweredFunc.func);
+          visitFunctionExpression(errors, instr.value.loweredFunc.func);
           break;
         }
         default: {
@@ -416,17 +421,20 @@ export function validateHooksUsage(fn: HIRFunction): void {
   }
 
   for (const [, error] of errorsByPlace) {
-    fn.env.recordError(error);
+    errors.pushErrorDetail(error);
+  }
+  if (errors.hasAnyErrors()) {
+    fn.env.recordErrors(errors);
   }
 }
 
-function visitFunctionExpression(env: Environment, fn: HIRFunction): void {
+function visitFunctionExpression(errors: CompilerError, fn: HIRFunction): void {
   for (const [, block] of fn.body.blocks) {
     for (const instr of block.instructions) {
       switch (instr.value.kind) {
         case 'ObjectMethod':
         case 'FunctionExpression': {
-          visitFunctionExpression(env, instr.value.loweredFunc.func);
+          visitFunctionExpression(errors, instr.value.loweredFunc.func);
           break;
         }
         case 'MethodCall':
@@ -437,7 +445,7 @@ function visitFunctionExpression(env: Environment, fn: HIRFunction): void {
               : instr.value.property;
           const hookKind = getHookKind(fn.env, callee.identifier);
           if (hookKind != null) {
-            env.recordError(
+            errors.pushErrorDetail(
               new CompilerErrorDetail({
                 category: ErrorCategory.Hooks,
                 reason:

compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateLocalsNotReassignedAfterRender.ts

@@ -7,7 +7,6 @@
 
 import {CompilerDiagnostic, CompilerError, Effect} from '..';
 import {ErrorCategory} from '../CompilerError';
-import {Environment} from '../HIR/Environment';
 import {HIRFunction, IdentifierId, Place} from '../HIR';
 import {
   eachInstructionLValue,
@@ -28,15 +27,15 @@ export function validateLocalsNotReassignedAfterRender(fn: HIRFunction): void {
     contextVariables,
     false,
     false,
-    fn.env,
   );
   if (reassignment !== null) {
+    const errors = new CompilerError();
     const variable =
       reassignment.identifier.name != null &&
       reassignment.identifier.name.kind === 'named'
         ? `\`${reassignment.identifier.name.value}\``
         : 'variable';
-    fn.env.recordError(
+    errors.pushDiagnostic(
       CompilerDiagnostic.create({
         category: ErrorCategory.Immutability,
         reason: 'Cannot reassign variable after render completes',
@@ -47,6 +46,7 @@ export function validateLocalsNotReassignedAfterRender(fn: HIRFunction): void {
         message: `Cannot reassign ${variable} after render completes`,
       }),
     );
+    throw errors;
   }
 }
 
@@ -55,7 +55,6 @@ function getContextReassignment(
   contextVariables: Set<IdentifierId>,
   isFunctionExpression: boolean,
   isAsync: boolean,
-  env: Environment,
 ): Place | null {
   const reassigningFunctions = new Map<IdentifierId, Place>();
   for (const [, block] of fn.body.blocks) {
@@ -69,7 +68,6 @@ function getContextReassignment(
             contextVariables,
             true,
             isAsync || value.loweredFunc.func.async,
-            env,
           );
           if (reassignment === null) {
             // If the function itself doesn't reassign, does one of its dependencies?
@@ -86,12 +84,13 @@ function getContextReassignment(
           // if the function or its depends reassign, propagate that fact on the lvalue
           if (reassignment !== null) {
             if (isAsync || value.loweredFunc.func.async) {
+              const errors = new CompilerError();
               const variable =
                 reassignment.identifier.name !== null &&
                 reassignment.identifier.name.kind === 'named'
                   ? `\`${reassignment.identifier.name.value}\``
                   : 'variable';
-              env.recordError(
+              errors.pushDiagnostic(
                 CompilerDiagnostic.create({
                   category: ErrorCategory.Immutability,
                   reason: 'Cannot reassign variable in async function',
@@ -103,7 +102,7 @@ function getContextReassignment(
                   message: `Cannot reassign ${variable}`,
                 }),
               );
-              return null;
+              throw errors;
             }
             reassigningFunctions.set(lvalue.identifier.id, reassignment);
           }

compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateNoCapitalizedCalls.ts

@@ -5,7 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import {CompilerErrorDetail, EnvironmentConfig} from '..';
+import {CompilerError, CompilerErrorDetail, EnvironmentConfig} from '..';
 import {ErrorCategory} from '../CompilerError';
 import {HIRFunction, IdentifierId} from '../HIR';
 import {DEFAULT_GLOBALS} from '../HIR/Globals';
@@ -20,6 +20,7 @@ export function validateNoCapitalizedCalls(fn: HIRFunction): void {
     return ALLOW_LIST.has(name);
   };
 
+  const errors = new CompilerError();
   const capitalLoadGlobals = new Map<IdentifierId, string>();
   const capitalizedProperties = new Map<IdentifierId, string>();
   const reason =
@@ -71,19 +72,20 @@ export function validateNoCapitalizedCalls(fn: HIRFunction): void {
           const propertyIdentifier = value.property.identifier.id;
           const propertyName = capitalizedProperties.get(propertyIdentifier);
           if (propertyName != null) {
-            fn.env.recordError(
-              new CompilerErrorDetail({
-                category: ErrorCategory.CapitalizedCalls,
-                reason,
-                description: `${propertyName} may be a component`,
-                loc: value.loc,
-                suggestions: null,
-              }),
-            );
+            errors.push({
+              category: ErrorCategory.CapitalizedCalls,
+              reason,
+              description: `${propertyName} may be a component`,
+              loc: value.loc,
+              suggestions: null,
+            });
           }
           break;
         }
       }
     }
   }
+  if (errors.hasAnyErrors()) {
+    fn.env.recordErrors(errors);
+  }
 }

compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateNoDerivedComputationsInEffects.ts

@@ -6,7 +6,7 @@
  */
 
 import {CompilerError, SourceLocation} from '..';
-import {CompilerErrorDetail, ErrorCategory} from '../CompilerError';
+import {ErrorCategory} from '../CompilerError';
 import {
   ArrayExpression,
   BlockId,
@@ -20,7 +20,6 @@ import {
   eachInstructionValueOperand,
   eachTerminalOperand,
 } from '../HIR/visitors';
-import {Environment} from '../HIR/Environment';
 
 /**
  * Validates that useEffect is not used for derived computations which could/should
@@ -50,6 +49,8 @@ export function validateNoDerivedComputationsInEffects(fn: HIRFunction): void {
   const functions: Map<IdentifierId, FunctionExpression> = new Map();
   const locals: Map<IdentifierId, IdentifierId> = new Map();
 
+  const errors = new CompilerError();
+
   for (const block of fn.body.blocks.values()) {
     for (const instr of block.instructions) {
       const {lvalue, value} = instr;
@@ -89,19 +90,22 @@ export function validateNoDerivedComputationsInEffects(fn: HIRFunction): void {
             validateEffect(
               effectFunction.loweredFunc.func,
               dependencies,
-              fn.env,
+              errors,
             );
           }
         }
       }
     }
   }
+  if (errors.hasAnyErrors()) {
+    throw errors;
+  }
 }
 
 function validateEffect(
   effectFunction: HIRFunction,
   effectDeps: Array<IdentifierId>,
-  env: Environment,
+  errors: CompilerError,
 ): void {
   for (const operand of effectFunction.context) {
     if (isSetStateType(operand.identifier)) {
@@ -215,15 +219,13 @@ function validateEffect(
   }
 
   for (const loc of setStateLocations) {
-    env.recordError(
-      new CompilerErrorDetail({
-        category: ErrorCategory.EffectDerivationsOfState,
-        reason:
-          'Values derived from props and state should be calculated during render, not in an effect. (https://react.dev/learn/you-might-not-need-an-effect#updating-state-based-on-props-or-state)',
-        description: null,
-        loc,
-        suggestions: null,
-      }),
-    );
+    errors.push({
+      category: ErrorCategory.EffectDerivationsOfState,
+      reason:
+        'Values derived from props and state should be calculated during render, not in an effect. (https://react.dev/learn/you-might-not-need-an-effect#updating-state-based-on-props-or-state)',
+      description: null,
+      loc,
+      suggestions: null,
+    });
   }
 }

compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateNoFreezingKnownMutableFunctions.ts

@@ -5,7 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import {CompilerDiagnostic, Effect} from '..';
+import {CompilerDiagnostic, CompilerError, Effect} from '..';
 import {ErrorCategory} from '../CompilerError';
 import {
   HIRFunction,
@@ -43,6 +43,7 @@ import {AliasingEffect} from '../Inference/AliasingEffects';
  * that are passed where a frozen value is expected and rejects them.
  */
 export function validateNoFreezingKnownMutableFunctions(fn: HIRFunction): void {
+  const errors = new CompilerError();
   const contextMutationEffects: Map<
     IdentifierId,
     Extract<AliasingEffect, {kind: 'Mutate'} | {kind: 'MutateTransitive'}>
@@ -59,7 +60,7 @@ export function validateNoFreezingKnownMutableFunctions(fn: HIRFunction): void {
           place.identifier.name.kind === 'named'
             ? `\`${place.identifier.name.value}\``
             : 'a local variable';
-        fn.env.recordError(
+        errors.pushDiagnostic(
           CompilerDiagnostic.create({
             category: ErrorCategory.Immutability,
             reason: 'Cannot modify local variables after render completes',
@@ -158,4 +159,7 @@ export function validateNoFreezingKnownMutableFunctions(fn: HIRFunction): void {
       visitOperand(operand);
     }
   }
+  if (errors.hasAnyErrors()) {
+    fn.env.recordErrors(errors);
+  }
 }

compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateNoImpureFunctionsInRender.ts

@@ -5,7 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import {CompilerDiagnostic} from '..';
+import {CompilerDiagnostic, CompilerError} from '..';
 import {ErrorCategory} from '../CompilerError';
 import {HIRFunction} from '../HIR';
 import {getFunctionCallSignature} from '../Inference/InferMutationAliasingEffects';
@@ -20,6 +20,7 @@ import {getFunctionCallSignature} from '../Inference/InferMutationAliasingEffect
  * and use it here.
  */
 export function validateNoImpureFunctionsInRender(fn: HIRFunction): void {
+  const errors = new CompilerError();
   for (const [, block] of fn.body.blocks) {
     for (const instr of block.instructions) {
       const value = instr.value;
@@ -31,7 +32,7 @@ export function validateNoImpureFunctionsInRender(fn: HIRFunction): void {
           callee.identifier.type,
         );
         if (signature != null && signature.impure === true) {
-          fn.env.recordError(
+          errors.pushDiagnostic(
             CompilerDiagnostic.create({
               category: ErrorCategory.Purity,
               reason: 'Cannot call impure function during render',
@@ -51,4 +52,7 @@ export function validateNoImpureFunctionsInRender(fn: HIRFunction): void {
       }
     }
   }
+  if (errors.hasAnyErrors()) {
+    fn.env.recordErrors(errors);
+  }
 }

compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateNoRefAccessInRender.ts

@@ -124,8 +124,8 @@ export function validateNoRefAccessInRender(fn: HIRFunction): void {
   collectTemporariesSidemap(fn, env);
   const errors = new CompilerError();
   validateNoRefAccessInRenderImpl(fn, env, errors);
-  for (const detail of errors.details) {
-    fn.env.recordError(detail);
+  if (errors.hasAnyErrors()) {
+    fn.env.recordErrors(errors);
   }
 }
 
@@ -487,26 +487,24 @@ function validateNoRefAccessInRenderImpl(
              */
             if (!didError) {
               const isRefLValue = isUseRefType(instr.lvalue.identifier);
-              if (
-                isRefLValue ||
-                (hookKind != null &&
-                  hookKind !== 'useState' &&
-                  hookKind !== 'useReducer')
-              ) {
-                for (const operand of eachInstructionValueOperand(
-                  instr.value,
-                )) {
+              for (const operand of eachInstructionValueOperand(instr.value)) {
+                /**
+                 * By default we check that function call operands are not refs,
+                 * ref values, or functions that can access refs.
+                 */
+                if (
+                  isRefLValue ||
+                  (hookKind != null &&
+                    hookKind !== 'useState' &&
+                    hookKind !== 'useReducer')
+                ) {
                   /**
                    * Allow passing refs or ref-accessing functions when:
                    * 1. lvalue is a ref (mergeRefs pattern: `mergeRefs(ref1, ref2)`)
                    * 2. calling hooks (independently validated for ref safety)
                    */
                   validateNoDirectRefValueAccess(errors, operand, env);
-                }
-              } else if (interpolatedAsJsx.has(instr.lvalue.identifier.id)) {
-                for (const operand of eachInstructionValueOperand(
-                  instr.value,
-                )) {
+                } else if (interpolatedAsJsx.has(instr.lvalue.identifier.id)) {
                   /**
                    * Special case: the lvalue is passed as a jsx child
                    *
@@ -515,98 +513,7 @@ function validateNoRefAccessInRenderImpl(
                    * render function which attempts to obey the rules.
                    */
                   validateNoRefValueAccess(errors, env, operand);
-                }
-              } else if (hookKind == null && instr.effects != null) {
-                /**
-                 * For non-hook functions with known aliasing effects, use the
-                 * effects to determine what validation to apply for each place.
-                 * Track visited id:kind pairs to avoid duplicate errors.
-                 */
-                const visitedEffects: Set<string> = new Set();
-                for (const effect of instr.effects) {
-                  let place: Place | null = null;
-                  let validation: 'ref-passed' | 'direct-ref' | 'none' = 'none';
-                  switch (effect.kind) {
-                    case 'Freeze': {
-                      place = effect.value;
-                      validation = 'direct-ref';
-                      break;
-                    }
-                    case 'Mutate':
-                    case 'MutateTransitive':
-                    case 'MutateConditionally':
-                    case 'MutateTransitiveConditionally': {
-                      place = effect.value;
-                      validation = 'ref-passed';
-                      break;
-                    }
-                    case 'Render': {
-                      place = effect.place;
-                      validation = 'ref-passed';
-                      break;
-                    }
-                    case 'Capture':
-                    case 'Alias':
-                    case 'MaybeAlias':
-                    case 'Assign':
-                    case 'CreateFrom': {
-                      place = effect.from;
-                      validation = 'ref-passed';
-                      break;
-                    }
-                    case 'ImmutableCapture': {
-                      /**
-                       * ImmutableCapture can come from two sources:
-                       * 1. A known signature that explicitly freezes the operand
-                       *    (e.g. PanResponder.create) — safe, the function doesn't
-                       *    call callbacks during render.
-                       * 2. Downgraded defaults when the operand is already frozen
-                       *    (e.g. foo(propRef)) — the function is unknown and may
-                       *    access the ref.
-                       *
-                       * We distinguish these by checking whether the same operand
-                       * also has a Freeze effect on this instruction, which only
-                       * comes from known signatures.
-                       */
-                      place = effect.from;
-                      const isFrozen = instr.effects.some(
-                        e =>
-                          e.kind === 'Freeze' &&
-                          e.value.identifier.id === effect.from.identifier.id,
-                      );
-                      validation = isFrozen ? 'direct-ref' : 'ref-passed';
-                      break;
-                    }
-                    case 'Create':
-                    case 'CreateFunction':
-                    case 'Apply':
-                    case 'Impure':
-                    case 'MutateFrozen':
-                    case 'MutateGlobal': {
-                      break;
-                    }
-                  }
-                  if (place !== null && validation !== 'none') {
-                    const key = `${place.identifier.id}:${validation}`;
-                    if (!visitedEffects.has(key)) {
-                      visitedEffects.add(key);
-                      if (validation === 'direct-ref') {
-                        validateNoDirectRefValueAccess(errors, place, env);
-                      } else {
-                        validateNoRefPassedToFunction(
-                          errors,
-                          env,
-                          place,
-                          place.loc,
-                        );
-                      }
-                    }
-                  }
-                }
-              } else {
-                for (const operand of eachInstructionValueOperand(
-                  instr.value,
-                )) {
+                } else {
                   validateNoRefPassedToFunction(
                     errors,
                     env,

compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateNoSetStateInRender.ts

@@ -48,8 +48,8 @@ export function validateNoSetStateInRender(fn: HIRFunction): void {
     fn,
     unconditionalSetStateFunctions,
   );
-  for (const detail of errors.details) {
-    fn.env.recordError(detail);
+  if (errors.hasAnyErrors()) {
+    fn.env.recordErrors(errors);
   }
 }
 

compiler/packages/babel-plugin-react-compiler/src/Validation/ValidatePreservedManualMemoization.ts

@@ -27,7 +27,6 @@ import {
   ScopeId,
   SourceLocation,
 } from '../HIR';
-import {Environment} from '../HIR/Environment';
 import {printIdentifier, printManualMemoDependency} from '../HIR/PrintHIR';
 import {
   eachInstructionValueLValue,
@@ -38,6 +37,7 @@ import {
   ReactiveFunctionVisitor,
   visitReactiveFunction,
 } from '../ReactiveScopes/visitors';
+import {Result} from '../Utils/Result';
 import {getOrInsertDefault} from '../Utils/utils';
 
 /**
@@ -47,12 +47,15 @@ import {getOrInsertDefault} from '../Utils/utils';
  * This can occur if a value's mutable range somehow extended to include a hook and
  * was pruned.
  */
-export function validatePreservedManualMemoization(fn: ReactiveFunction): void {
+export function validatePreservedManualMemoization(
+  fn: ReactiveFunction,
+): Result<void, CompilerError> {
   const state = {
-    env: fn.env,
+    errors: new CompilerError(),
     manualMemoState: null,
   };
   visitReactiveFunction(fn, new Visitor(), state);
+  return state.errors.asResult();
 }
 
 const DEBUG = false;
@@ -110,7 +113,7 @@ type ManualMemoBlockState = {
 };
 
 type VisitorState = {
-  env: Environment;
+  errors: CompilerError;
   manualMemoState: ManualMemoBlockState | null;
 };
 
@@ -230,7 +233,7 @@ function validateInferredDep(
   temporaries: Map<IdentifierId, ManualMemoDependency>,
   declsWithinMemoBlock: Set<DeclarationId>,
   validDepsInMemoBlock: Array<ManualMemoDependency>,
-  env: Environment,
+  errorState: CompilerError,
   memoLocation: SourceLocation,
 ): void {
   let normalizedDep: ManualMemoDependency;
@@ -280,7 +283,7 @@ function validateInferredDep(
       errorDiagnostic = merge(errorDiagnostic ?? compareResult, compareResult);
     }
   }
-  env.recordError(
+  errorState.pushDiagnostic(
     CompilerDiagnostic.create({
       category: ErrorCategory.PreserveManualMemo,
       reason: 'Existing memoization could not be preserved',
@@ -426,7 +429,7 @@ class Visitor extends ReactiveFunctionVisitor<VisitorState> {
           this.temporaries,
           state.manualMemoState.decls,
           state.manualMemoState.depsFromSource,
-          state.env,
+          state.errors,
           state.manualMemoState.loc,
         );
       }
@@ -529,7 +532,7 @@ class Visitor extends ReactiveFunctionVisitor<VisitorState> {
           !this.scopes.has(identifier.scope.id) &&
           !this.prunedScopes.has(identifier.scope.id)
         ) {
-          state.env.recordError(
+          state.errors.pushDiagnostic(
             CompilerDiagnostic.create({
               category: ErrorCategory.PreserveManualMemo,
               reason: 'Existing memoization could not be preserved',
@@ -575,7 +578,7 @@ class Visitor extends ReactiveFunctionVisitor<VisitorState> {
 
           for (const identifier of decls) {
             if (isUnmemoized(identifier, this.scopes)) {
-              state.env.recordError(
+              state.errors.pushDiagnostic(
                 CompilerDiagnostic.create({
                   category: ErrorCategory.PreserveManualMemo,
                   reason: 'Existing memoization could not be preserved',

compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateSourceLocations.ts

@@ -7,9 +7,9 @@
 
 import {NodePath} from '@babel/traverse';
 import * as t from '@babel/types';
-import {CompilerDiagnostic, ErrorCategory} from '..';
+import {CompilerDiagnostic, CompilerError, ErrorCategory} from '..';
 import {CodegenFunction} from '../ReactiveScopes';
-import {Environment} from '../HIR/Environment';
+import {Result} from '../Utils/Result';
 
 /**
  * IMPORTANT: This validation is only intended for use in unit tests.
@@ -123,8 +123,9 @@ export function validateSourceLocations(
     t.FunctionDeclaration | t.ArrowFunctionExpression | t.FunctionExpression
   >,
   generatedAst: CodegenFunction,
-  env: Environment,
-): void {
+): Result<void, CompilerError> {
+  const errors = new CompilerError();
+
   /*
    * Step 1: Collect important locations from the original source
    * Note: Multiple node types can share the same location (e.g. VariableDeclarator and Identifier)
@@ -239,7 +240,7 @@ export function validateSourceLocations(
     loc: t.SourceLocation,
     nodeType: string,
   ): void => {
-    env.recordError(
+    errors.pushDiagnostic(
       CompilerDiagnostic.create({
         category: ErrorCategory.Todo,
         reason: 'Important source location missing in generated code',
@@ -259,7 +260,7 @@ export function validateSourceLocations(
     expectedType: string,
     actualTypes: Set<string>,
   ): void => {
-    env.recordError(
+    errors.pushDiagnostic(
       CompilerDiagnostic.create({
         category: ErrorCategory.Todo,
         reason:
@@ -307,4 +308,6 @@ export function validateSourceLocations(
       }
     }
   }
+
+  return errors.asResult();
 }

compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateUseMemo.ts

@@ -16,13 +16,13 @@ import {
   IdentifierId,
   SourceLocation,
 } from '../HIR';
-import {Environment} from '../HIR/Environment';
 import {
   eachInstructionValueOperand,
   eachTerminalOperand,
 } from '../HIR/visitors';
 
 export function validateUseMemo(fn: HIRFunction): void {
+  const errors = new CompilerError();
   const voidMemoErrors = new CompilerError();
   const useMemos = new Set<IdentifierId>();
   const react = new Set<IdentifierId>();
@@ -90,7 +90,7 @@ export function validateUseMemo(fn: HIRFunction): void {
               firstParam.kind === 'Identifier'
                 ? firstParam.loc
                 : firstParam.place.loc;
-            fn.env.recordError(
+            errors.pushDiagnostic(
               CompilerDiagnostic.create({
                 category: ErrorCategory.UseMemo,
                 reason: 'useMemo() callbacks may not accept parameters',
@@ -106,7 +106,7 @@ export function validateUseMemo(fn: HIRFunction): void {
           }
 
           if (body.loweredFunc.func.async || body.loweredFunc.func.generator) {
-            fn.env.recordError(
+            errors.pushDiagnostic(
               CompilerDiagnostic.create({
                 category: ErrorCategory.UseMemo,
                 reason:
@@ -122,7 +122,7 @@ export function validateUseMemo(fn: HIRFunction): void {
             );
           }
 
-          validateNoContextVariableAssignment(body.loweredFunc.func, fn.env);
+          validateNoContextVariableAssignment(body.loweredFunc.func, errors);
 
           if (fn.env.config.validateNoVoidUseMemo) {
             if (!hasNonVoidReturn(body.loweredFunc.func)) {
@@ -176,11 +176,14 @@ export function validateUseMemo(fn: HIRFunction): void {
     }
   }
   fn.env.logErrors(voidMemoErrors.asResult());
+  if (errors.hasAnyErrors()) {
+    fn.env.recordErrors(errors);
+  }
 }
 
 function validateNoContextVariableAssignment(
   fn: HIRFunction,
-  env: Environment,
+  errors: CompilerError,
 ): void {
   const context = new Set(fn.context.map(place => place.identifier.id));
   for (const block of fn.body.blocks.values()) {
@@ -189,7 +192,7 @@ function validateNoContextVariableAssignment(
       switch (value.kind) {
         case 'StoreContext': {
           if (context.has(value.lvalue.place.identifier.id)) {
-            env.recordError(
+            errors.pushDiagnostic(
               CompilerDiagnostic.create({
                 category: ErrorCategory.UseMemo,
                 reason:

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/ecma/error.reserved-words.expect.md

@@ -24,9 +24,18 @@ function useThing(fn) {
 ```
 Found 1 error:
 
-Error: Expected a non-reserved identifier name
+Compilation Skipped: `this` is not supported syntax
 
-`this` is a reserved word in JavaScript and cannot be used as an identifier name.
+React Compiler does not support compiling functions that use `this`.
+
+error.reserved-words.ts:8:28
+   6 |
+   7 |   if (ref.current === null) {
+>  8 |     ref.current = function (this: unknown, ...args) {
+     |                             ^^^^^^^^^^^^^ `this` was used here
+   9 |       return fnRef.current.call(this, ...args);
+  10 |     };
+  11 |   }
 ```
           
       

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error._todo.computed-lval-in-destructure.expect.md

@@ -17,17 +17,16 @@ function Component(props) {
 ```
 Found 1 error:
 
-Invariant: [InferMutationAliasingEffects] Expected value kind to be initialized
+Todo: (BuildHIR::lowerAssignment) Handle computed properties in ObjectPattern
 
-<unknown> x$8.
-
-error._todo.computed-lval-in-destructure.ts:5:9
-  3 |   const {[computedKey]: x} = props.val;
+error._todo.computed-lval-in-destructure.ts:3:9
+  1 | function Component(props) {
+  2 |   const computedKey = props.key;
+> 3 |   const {[computedKey]: x} = props.val;
+    |          ^^^^^^^^^^^^^^^^ (BuildHIR::lowerAssignment) Handle computed properties in ObjectPattern
   4 |
-> 5 |   return x;
-    |          ^ this is uninitialized
+  5 |   return x;
   6 | }
-  7 |
 ```
           
       

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.fault-tolerance-reports-multiple-errors.expect.md

@@ -1,60 +0,0 @@
-
-## Input
-
-```javascript
-// @validateRefAccessDuringRender
-/**
- * This fixture tests fault tolerance: the compiler should report
- * multiple independent errors rather than stopping at the first one.
- *
- * Error 1: Ref access during render (ref.current)
- * Error 2: Mutation of frozen value (props)
- */
-function Component(props) {
-  const ref = useRef(null);
-
-  // Error: reading ref during render
-  const value = ref.current;
-
-  // Error: mutating frozen value (props, which is frozen after hook call)
-  props.items = [];
-
-  return <div>{value}</div>;
-}
-
-```
-
-
-## Error
-
-```
-Found 2 errors:
-
-Error: This value cannot be modified
-
-Modifying component props or hook arguments is not allowed. Consider using a local variable instead.
-
-error.fault-tolerance-reports-multiple-errors.ts:16:2
-  14 |
-  15 |   // Error: mutating frozen value (props, which is frozen after hook call)
-> 16 |   props.items = [];
-     |   ^^^^^ value cannot be modified
-  17 |
-  18 |   return <div>{value}</div>;
-  19 | }
-
-Error: Cannot access refs during render
-
-React refs are values that are not needed for rendering. Refs should only be accessed outside of render, such as in event handlers or effects. Accessing a ref value (the `current` property) during render can cause your component not to update as expected (https://react.dev/reference/react/useRef).
-
-error.fault-tolerance-reports-multiple-errors.ts:13:16
-  11 |
-  12 |   // Error: reading ref during render
-> 13 |   const value = ref.current;
-     |                 ^^^^^^^^^^^ Cannot access ref value during render
-  14 |
-  15 |   // Error: mutating frozen value (props, which is frozen after hook call)
-  16 |   props.items = [];
-```
-          
-      

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.fault-tolerance-reports-multiple-errors.js

@@ -1,19 +0,0 @@
-// @validateRefAccessDuringRender
-/**
- * This fixture tests fault tolerance: the compiler should report
- * multiple independent errors rather than stopping at the first one.
- *
- * Error 1: Ref access during render (ref.current)
- * Error 2: Mutation of frozen value (props)
- */
-function Component(props) {
-  const ref = useRef(null);
-
-  // Error: reading ref during render
-  const value = ref.current;
-
-  // Error: mutating frozen value (props, which is frozen after hook call)
-  props.items = [];
-
-  return <div>{value}</div>;
-}

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.todo-hoisted-function-in-unreachable-code.expect.md

@@ -18,18 +18,15 @@ function Component() {
 ```
 Found 1 error:
 
-Invariant: [InferMutationAliasingEffects] Expected value kind to be initialized
+Todo: Support functions with unreachable code that may contain hoisted declarations
 
-<unknown> Foo$0.
-
-error.todo-hoisted-function-in-unreachable-code.ts:3:10
-  1 | // @compilationMode:"infer"
-  2 | function Component() {
-> 3 |   return <Foo />;
-    |           ^^^ this is uninitialized
+error.todo-hoisted-function-in-unreachable-code.ts:6:2
   4 |
   5 |   // This is unreachable from a control-flow perspective, but it gets hoisted
-  6 |   function Foo() {}
+> 6 |   function Foo() {}
+    |   ^^^^^^^^^^^^^^^^^ Support functions with unreachable code that may contain hoisted declarations
+  7 | }
+  8 |
 ```
           
       

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.todo-kitchensink.expect.md

@@ -79,11 +79,43 @@ let moduleLocal = false;
 ## Error
 
 ```
-Found 1 error:
+Found 10 errors:
 
-Invariant: Expected a variable declaration
+Todo: (BuildHIR::lowerStatement) Handle var kinds in VariableDeclaration
 
-Got ExpressionStatement.
+error.todo-kitchensink.ts:3:2
+  1 | function foo([a, b], {c, d, e = 'e'}, f = 'f', ...args) {
+  2 |   let i = 0;
+> 3 |   var x = [];
+    |   ^^^^^^^^^^^ (BuildHIR::lowerStatement) Handle var kinds in VariableDeclaration
+  4 |
+  5 |   class Bar {
+  6 |     #secretSauce = 42;
+
+Compilation Skipped: Inline `class` declarations are not supported
+
+Move class declarations outside of components/hooks.
+
+error.todo-kitchensink.ts:5:2
+   3 |   var x = [];
+   4 |
+>  5 |   class Bar {
+     |   ^^^^^^^^^^^
+>  6 |     #secretSauce = 42;
+     | ^^^^^^^^^^^^^^^^^^^^^^
+>  7 |     constructor() {
+     | ^^^^^^^^^^^^^^^^^^^^^^
+>  8 |       console.log(this.#secretSauce);
+     | ^^^^^^^^^^^^^^^^^^^^^^
+>  9 |     }
+     | ^^^^^^^^^^^^^^^^^^^^^^
+> 10 |   }
+     | ^^^^ Inline `class` declarations are not supported
+  11 |
+  12 |   const g = {b() {}, c: () => {}};
+  13 |   const {z, aa = 'aa'} = useCustom();
+
+Todo: (BuildHIR::lowerStatement) Handle non-variable initialization in ForStatement
 
 error.todo-kitchensink.ts:20:2
   18 |   const j = function bar([quz, qux], ...args) {};
@@ -93,10 +125,103 @@ error.todo-kitchensink.ts:20:2
 > 21 |     x.push(i);
      | ^^^^^^^^^^^^^^
 > 22 |   }
-     | ^^^^ Expected a variable declaration
+     | ^^^^ (BuildHIR::lowerStatement) Handle non-variable initialization in ForStatement
   23 |   for (; i < 3; ) {
   24 |     break;
   25 |   }
+
+Todo: (BuildHIR::lowerStatement) Handle non-variable initialization in ForStatement
+
+error.todo-kitchensink.ts:23:2
+  21 |     x.push(i);
+  22 |   }
+> 23 |   for (; i < 3; ) {
+     |   ^^^^^^^^^^^^^^^^^
+> 24 |     break;
+     | ^^^^^^^^^^
+> 25 |   }
+     | ^^^^ (BuildHIR::lowerStatement) Handle non-variable initialization in ForStatement
+  26 |   for (;;) {
+  27 |     break;
+  28 |   }
+
+Todo: (BuildHIR::lowerStatement) Handle non-variable initialization in ForStatement
+
+error.todo-kitchensink.ts:26:2
+  24 |     break;
+  25 |   }
+> 26 |   for (;;) {
+     |   ^^^^^^^^^^
+> 27 |     break;
+     | ^^^^^^^^^^
+> 28 |   }
+     | ^^^^ (BuildHIR::lowerStatement) Handle non-variable initialization in ForStatement
+  29 |
+  30 |   graphql`
+  31 |     ${g}
+
+Todo: (BuildHIR::lowerStatement) Handle empty test in ForStatement
+
+error.todo-kitchensink.ts:26:2
+  24 |     break;
+  25 |   }
+> 26 |   for (;;) {
+     |   ^^^^^^^^^^
+> 27 |     break;
+     | ^^^^^^^^^^
+> 28 |   }
+     | ^^^^ (BuildHIR::lowerStatement) Handle empty test in ForStatement
+  29 |
+  30 |   graphql`
+  31 |     ${g}
+
+Todo: (BuildHIR::lowerExpression) Handle tagged template with interpolations
+
+error.todo-kitchensink.ts:30:2
+  28 |   }
+  29 |
+> 30 |   graphql`
+     |   ^^^^^^^^
+> 31 |     ${g}
+     | ^^^^^^^^
+> 32 |   `;
+     | ^^^^ (BuildHIR::lowerExpression) Handle tagged template with interpolations
+  33 |
+  34 |   graphql`\\t\n`;
+  35 |
+
+Todo: (BuildHIR::lowerExpression) Handle tagged template where cooked value is different from raw value
+
+error.todo-kitchensink.ts:34:2
+  32 |   `;
+  33 |
+> 34 |   graphql`\\t\n`;
+     |   ^^^^^^^^^^^^^^ (BuildHIR::lowerExpression) Handle tagged template where cooked value is different from raw value
+  35 |
+  36 |   for (c of [1, 2]) {
+  37 |   }
+
+Todo: (BuildHIR::node.lowerReorderableExpression) Expression type `MemberExpression` cannot be safely reordered
+
+error.todo-kitchensink.ts:57:9
+  55 |     case foo(): {
+  56 |     }
+> 57 |     case x.y: {
+     |          ^^^ (BuildHIR::node.lowerReorderableExpression) Expression type `MemberExpression` cannot be safely reordered
+  58 |     }
+  59 |     default: {
+  60 |     }
+
+Todo: (BuildHIR::node.lowerReorderableExpression) Expression type `BinaryExpression` cannot be safely reordered
+
+error.todo-kitchensink.ts:53:9
+  51 |
+  52 |   switch (i) {
+> 53 |     case 1 + 1: {
+     |          ^^^^^ (BuildHIR::node.lowerReorderableExpression) Expression type `BinaryExpression` cannot be safely reordered
+  54 |     }
+  55 |     case foo(): {
+  56 |     }
 ```
           
       

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.todo-optional-call-chain-in-optional.expect.md

@@ -0,0 +1,39 @@
+
+## Input
+
+```javascript
+function useFoo(props: {value: {x: string; y: string} | null}) {
+  const value = props.value;
+  return createArray(value?.x, value?.y)?.join(', ');
+}
+
+function createArray<T>(...args: Array<T>): Array<T> {
+  return args;
+}
+
+export const FIXTURE_ENTRYPONT = {
+  fn: useFoo,
+  props: [{value: null}],
+};
+
+```
+
+
+## Error
+
+```
+Found 1 error:
+
+Todo: Unexpected terminal kind `optional` for optional fallthrough block
+
+error.todo-optional-call-chain-in-optional.ts:3:21
+  1 | function useFoo(props: {value: {x: string; y: string} | null}) {
+  2 |   const value = props.value;
+> 3 |   return createArray(value?.x, value?.y)?.join(', ');
+    |                      ^^^^^^^^ Unexpected terminal kind `optional` for optional fallthrough block
+  4 | }
+  5 |
+  6 | function createArray<T>(...args: Array<T>): Array<T> {
+```
+          
+      

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.todo-reassign-const.expect.md

@@ -21,7 +21,7 @@ function Component({foo}) {
 ## Error
 
 ```
-Found 3 errors:
+Found 2 errors:
 
 Todo: Support destructuring of context variables
 
@@ -29,18 +29,7 @@ error.todo-reassign-const.ts:3:20
   1 | import {Stringify} from 'shared-runtime';
   2 |
 > 3 | function Component({foo}) {
-    |                     ^^^
-  4 |   let bar = foo.bar;
-  5 |   return (
-  6 |     <Stringify
-
-Todo: Support destructuring of context variables
-
-error.todo-reassign-const.ts:3:20
-  1 | import {Stringify} from 'shared-runtime';
-  2 |
-> 3 | function Component({foo}) {
-    |                     ^^^
+    |                     ^^^ Support destructuring of context variables
   4 |   let bar = foo.bar;
   5 |   return (
   6 |     <Stringify

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.useMemo-callback-generator.expect.md

@@ -18,7 +18,7 @@ function component(a, b) {
 ## Error
 
 ```
-Found 2 errors:
+Found 1 error:
 
 Todo: (BuildHIR::lowerExpression) Handle YieldExpression expressions
 
@@ -30,23 +30,6 @@ error.useMemo-callback-generator.ts:6:4
   7 |   }, []);
   8 |   return x;
   9 | }
-
-Error: useMemo() callbacks may not be async or generator functions
-
-useMemo() callbacks are called once and must synchronously return a value.
-
-error.useMemo-callback-generator.ts:5:18
-   3 |   // useful for now, but adding this test in case we do
-   4 |   // add support for generators in the future.
->  5 |   let x = useMemo(function* () {
-     |                   ^^^^^^^^^^^^^^
->  6 |     yield a;
-     | ^^^^^^^^^^^^
->  7 |   }, []);
-     | ^^^^ Async and generator functions are not supported
-   8 |   return x;
-   9 | }
-  10 |
 ```
           
       

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.validate-mutate-ref-arg-in-render.expect.md

@@ -3,10 +3,8 @@
 
 ```javascript
 // @validateRefAccessDuringRender:true
-import {mutate} from 'shared-runtime';
-
 function Foo(props, ref) {
-  mutate(ref.current);
+  console.log(ref.current);
   return <div>{props.bar}</div>;
 }
 
@@ -28,14 +26,14 @@ Error: Cannot access refs during render
 
 React refs are values that are not needed for rendering. Refs should only be accessed outside of render, such as in event handlers or effects. Accessing a ref value (the `current` property) during render can cause your component not to update as expected (https://react.dev/reference/react/useRef).
 
-error.validate-mutate-ref-arg-in-render.ts:5:9
-  3 |
-  4 | function Foo(props, ref) {
-> 5 |   mutate(ref.current);
-    |          ^^^^^^^^^^^ Passing a ref to a function may read its value during render
-  6 |   return <div>{props.bar}</div>;
-  7 | }
-  8 |
+error.validate-mutate-ref-arg-in-render.ts:3:14
+  1 | // @validateRefAccessDuringRender:true
+  2 | function Foo(props, ref) {
+> 3 |   console.log(ref.current);
+    |               ^^^^^^^^^^^ Passing a ref to a function may read its value during render
+  4 |   return <div>{props.bar}</div>;
+  5 | }
+  6 |
 ```
           
       

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/error.validate-mutate-ref-arg-in-render.js

@@ -1,8 +1,6 @@
 // @validateRefAccessDuringRender:true
-import {mutate} from 'shared-runtime';
-
 function Foo(props, ref) {
-  mutate(ref.current);
+  console.log(ref.current);
   return <div>{props.bar}</div>;
 }
 

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/fault-tolerance/error.try-finally-and-mutation-of-props.expect.md

@@ -1,66 +0,0 @@
-
-## Input
-
-```javascript
-/**
- * Fault tolerance test: two independent errors should both be reported.
- *
- * Error 1 (BuildHIR): `try/finally` is not supported
- * Error 2 (InferMutationAliasingEffects): Mutation of frozen props
- */
-function Component(props) {
-  // Error: try/finally (Todo from BuildHIR)
-  try {
-    doWork();
-  } finally {
-    doCleanup();
-  }
-
-  // Error: mutating frozen props
-  props.value = 1;
-
-  return <div>{props.value}</div>;
-}
-
-```
-
-
-## Error
-
-```
-Found 2 errors:
-
-Todo: (BuildHIR::lowerStatement) Handle TryStatement without a catch clause
-
-error.try-finally-and-mutation-of-props.ts:9:2
-   7 | function Component(props) {
-   8 |   // Error: try/finally (Todo from BuildHIR)
->  9 |   try {
-     |   ^^^^^
-> 10 |     doWork();
-     | ^^^^^^^^^^^^^
-> 11 |   } finally {
-     | ^^^^^^^^^^^^^
-> 12 |     doCleanup();
-     | ^^^^^^^^^^^^^
-> 13 |   }
-     | ^^^^ (BuildHIR::lowerStatement) Handle TryStatement without a catch clause
-  14 |
-  15 |   // Error: mutating frozen props
-  16 |   props.value = 1;
-
-Error: This value cannot be modified
-
-Modifying component props or hook arguments is not allowed. Consider using a local variable instead.
-
-error.try-finally-and-mutation-of-props.ts:16:2
-  14 |
-  15 |   // Error: mutating frozen props
-> 16 |   props.value = 1;
-     |   ^^^^^ value cannot be modified
-  17 |
-  18 |   return <div>{props.value}</div>;
-  19 | }
-```
-          
-      

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/fault-tolerance/error.try-finally-and-mutation-of-props.js

@@ -1,19 +0,0 @@
-/**
- * Fault tolerance test: two independent errors should both be reported.
- *
- * Error 1 (BuildHIR): `try/finally` is not supported
- * Error 2 (InferMutationAliasingEffects): Mutation of frozen props
- */
-function Component(props) {
-  // Error: try/finally (Todo from BuildHIR)
-  try {
-    doWork();
-  } finally {
-    doCleanup();
-  }
-
-  // Error: mutating frozen props
-  props.value = 1;
-
-  return <div>{props.value}</div>;
-}

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/fault-tolerance/error.try-finally-and-ref-access.expect.md

@@ -1,69 +0,0 @@
-
-## Input
-
-```javascript
-// @validateRefAccessDuringRender
-/**
- * Fault tolerance test: two independent errors should both be reported.
- *
- * Error 1 (BuildHIR): `try/finally` is not supported
- * Error 2 (ValidateNoRefAccessInRender): reading ref.current during render
- */
-function Component() {
-  const ref = useRef(null);
-
-  // Error: try/finally (Todo from BuildHIR)
-  try {
-    doSomething();
-  } finally {
-    cleanup();
-  }
-
-  // Error: reading ref during render
-  const value = ref.current;
-
-  return <div>{value}</div>;
-}
-
-```
-
-
-## Error
-
-```
-Found 2 errors:
-
-Todo: (BuildHIR::lowerStatement) Handle TryStatement without a catch clause
-
-error.try-finally-and-ref-access.ts:12:2
-  10 |
-  11 |   // Error: try/finally (Todo from BuildHIR)
-> 12 |   try {
-     |   ^^^^^
-> 13 |     doSomething();
-     | ^^^^^^^^^^^^^^^^^^
-> 14 |   } finally {
-     | ^^^^^^^^^^^^^^^^^^
-> 15 |     cleanup();
-     | ^^^^^^^^^^^^^^^^^^
-> 16 |   }
-     | ^^^^ (BuildHIR::lowerStatement) Handle TryStatement without a catch clause
-  17 |
-  18 |   // Error: reading ref during render
-  19 |   const value = ref.current;
-
-Error: Cannot access refs during render
-
-React refs are values that are not needed for rendering. Refs should only be accessed outside of render, such as in event handlers or effects. Accessing a ref value (the `current` property) during render can cause your component not to update as expected (https://react.dev/reference/react/useRef).
-
-error.try-finally-and-ref-access.ts:19:16
-  17 |
-  18 |   // Error: reading ref during render
-> 19 |   const value = ref.current;
-     |                 ^^^^^^^^^^^ Cannot access ref value during render
-  20 |
-  21 |   return <div>{value}</div>;
-  22 | }
-```
-          
-      

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/fault-tolerance/error.try-finally-and-ref-access.js

@@ -1,22 +0,0 @@
-// @validateRefAccessDuringRender
-/**
- * Fault tolerance test: two independent errors should both be reported.
- *
- * Error 1 (BuildHIR): `try/finally` is not supported
- * Error 2 (ValidateNoRefAccessInRender): reading ref.current during render
- */
-function Component() {
-  const ref = useRef(null);
-
-  // Error: try/finally (Todo from BuildHIR)
-  try {
-    doSomething();
-  } finally {
-    cleanup();
-  }
-
-  // Error: reading ref during render
-  const value = ref.current;
-
-  return <div>{value}</div>;
-}

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/fault-tolerance/error.try-finally-ref-access-and-mutation.expect.md

@@ -1,86 +0,0 @@
-
-## Input
-
-```javascript
-// @validateRefAccessDuringRender
-/**
- * Fault tolerance test: three independent errors should all be reported.
- *
- * Error 1 (BuildHIR): `try/finally` is not supported
- * Error 2 (ValidateNoRefAccessInRender): reading ref.current during render
- * Error 3 (InferMutationAliasingEffects): Mutation of frozen props
- */
-function Component(props) {
-  const ref = useRef(null);
-
-  // Error: try/finally (Todo from BuildHIR)
-  try {
-    doWork();
-  } finally {
-    cleanup();
-  }
-
-  // Error: reading ref during render
-  const value = ref.current;
-
-  // Error: mutating frozen props
-  props.items = [];
-
-  return <div>{value}</div>;
-}
-
-```
-
-
-## Error
-
-```
-Found 3 errors:
-
-Todo: (BuildHIR::lowerStatement) Handle TryStatement without a catch clause
-
-error.try-finally-ref-access-and-mutation.ts:13:2
-  11 |
-  12 |   // Error: try/finally (Todo from BuildHIR)
-> 13 |   try {
-     |   ^^^^^
-> 14 |     doWork();
-     | ^^^^^^^^^^^^^
-> 15 |   } finally {
-     | ^^^^^^^^^^^^^
-> 16 |     cleanup();
-     | ^^^^^^^^^^^^^
-> 17 |   }
-     | ^^^^ (BuildHIR::lowerStatement) Handle TryStatement without a catch clause
-  18 |
-  19 |   // Error: reading ref during render
-  20 |   const value = ref.current;
-
-Error: This value cannot be modified
-
-Modifying component props or hook arguments is not allowed. Consider using a local variable instead.
-
-error.try-finally-ref-access-and-mutation.ts:23:2
-  21 |
-  22 |   // Error: mutating frozen props
-> 23 |   props.items = [];
-     |   ^^^^^ value cannot be modified
-  24 |
-  25 |   return <div>{value}</div>;
-  26 | }
-
-Error: Cannot access refs during render
-
-React refs are values that are not needed for rendering. Refs should only be accessed outside of render, such as in event handlers or effects. Accessing a ref value (the `current` property) during render can cause your component not to update as expected (https://react.dev/reference/react/useRef).
-
-error.try-finally-ref-access-and-mutation.ts:20:16
-  18 |
-  19 |   // Error: reading ref during render
-> 20 |   const value = ref.current;
-     |                 ^^^^^^^^^^^ Cannot access ref value during render
-  21 |
-  22 |   // Error: mutating frozen props
-  23 |   props.items = [];
-```
-          
-      

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/fault-tolerance/error.try-finally-ref-access-and-mutation.js

@@ -1,26 +0,0 @@
-// @validateRefAccessDuringRender
-/**
- * Fault tolerance test: three independent errors should all be reported.
- *
- * Error 1 (BuildHIR): `try/finally` is not supported
- * Error 2 (ValidateNoRefAccessInRender): reading ref.current during render
- * Error 3 (InferMutationAliasingEffects): Mutation of frozen props
- */
-function Component(props) {
-  const ref = useRef(null);
-
-  // Error: try/finally (Todo from BuildHIR)
-  try {
-    doWork();
-  } finally {
-    cleanup();
-  }
-
-  // Error: reading ref during render
-  const value = ref.current;
-
-  // Error: mutating frozen props
-  props.items = [];
-
-  return <div>{value}</div>;
-}

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/fault-tolerance/error.var-declaration-and-mutation-of-props.expect.md

@@ -1,54 +0,0 @@
-
-## Input
-
-```javascript
-/**
- * Fault tolerance test: two independent errors should both be reported.
- *
- * Error 1 (BuildHIR): `var` declarations are not supported (treated as `let`)
- * Error 2 (InferMutationAliasingEffects): Mutation of frozen props
- */
-function Component(props) {
-  // Error: var declaration (Todo from BuildHIR)
-  var items = props.items;
-
-  // Error: mutating frozen props (detected during inference)
-  props.items = [];
-
-  return <div>{items.length}</div>;
-}
-
-```
-
-
-## Error
-
-```
-Found 2 errors:
-
-Todo: (BuildHIR::lowerStatement) Handle var kinds in VariableDeclaration
-
-error.var-declaration-and-mutation-of-props.ts:9:2
-   7 | function Component(props) {
-   8 |   // Error: var declaration (Todo from BuildHIR)
->  9 |   var items = props.items;
-     |   ^^^^^^^^^^^^^^^^^^^^^^^^ (BuildHIR::lowerStatement) Handle var kinds in VariableDeclaration
-  10 |
-  11 |   // Error: mutating frozen props (detected during inference)
-  12 |   props.items = [];
-
-Error: This value cannot be modified
-
-Modifying component props or hook arguments is not allowed. Consider using a local variable instead.
-
-error.var-declaration-and-mutation-of-props.ts:12:2
-  10 |
-  11 |   // Error: mutating frozen props (detected during inference)
-> 12 |   props.items = [];
-     |   ^^^^^ value cannot be modified
-  13 |
-  14 |   return <div>{items.length}</div>;
-  15 | }
-```
-          
-      

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/fault-tolerance/error.var-declaration-and-mutation-of-props.js

@@ -1,15 +0,0 @@
-/**
- * Fault tolerance test: two independent errors should both be reported.
- *
- * Error 1 (BuildHIR): `var` declarations are not supported (treated as `let`)
- * Error 2 (InferMutationAliasingEffects): Mutation of frozen props
- */
-function Component(props) {
-  // Error: var declaration (Todo from BuildHIR)
-  var items = props.items;
-
-  // Error: mutating frozen props (detected during inference)
-  props.items = [];
-
-  return <div>{items.length}</div>;
-}

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/fault-tolerance/error.var-declaration-and-ref-access.expect.md

@@ -1,62 +0,0 @@
-
-## Input
-
-```javascript
-// @validateRefAccessDuringRender
-/**
- * Fault tolerance test: two independent errors should both be reported.
- *
- * Error 1 (BuildHIR): `var` declarations are not supported (treated as `let`)
- * Error 2 (ValidateNoRefAccessInRender): reading ref.current during render
- */
-function Component() {
-  const ref = useRef(null);
-
-  // Error: var declaration (Todo from BuildHIR)
-  var items = [1, 2, 3];
-
-  // Error: reading ref during render
-  const value = ref.current;
-
-  return (
-    <div>
-      {value}
-      {items.length}
-    </div>
-  );
-}
-
-```
-
-
-## Error
-
-```
-Found 2 errors:
-
-Todo: (BuildHIR::lowerStatement) Handle var kinds in VariableDeclaration
-
-error.var-declaration-and-ref-access.ts:12:2
-  10 |
-  11 |   // Error: var declaration (Todo from BuildHIR)
-> 12 |   var items = [1, 2, 3];
-     |   ^^^^^^^^^^^^^^^^^^^^^^ (BuildHIR::lowerStatement) Handle var kinds in VariableDeclaration
-  13 |
-  14 |   // Error: reading ref during render
-  15 |   const value = ref.current;
-
-Error: Cannot access refs during render
-
-React refs are values that are not needed for rendering. Refs should only be accessed outside of render, such as in event handlers or effects. Accessing a ref value (the `current` property) during render can cause your component not to update as expected (https://react.dev/reference/react/useRef).
-
-error.var-declaration-and-ref-access.ts:15:16
-  13 |
-  14 |   // Error: reading ref during render
-> 15 |   const value = ref.current;
-     |                 ^^^^^^^^^^^ Cannot access ref value during render
-  16 |
-  17 |   return (
-  18 |     <div>
-```
-          
-      

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/fault-tolerance/error.var-declaration-and-ref-access.js

@@ -1,23 +0,0 @@
-// @validateRefAccessDuringRender
-/**
- * Fault tolerance test: two independent errors should both be reported.
- *
- * Error 1 (BuildHIR): `var` declarations are not supported (treated as `let`)
- * Error 2 (ValidateNoRefAccessInRender): reading ref.current during render
- */
-function Component() {
-  const ref = useRef(null);
-
-  // Error: var declaration (Todo from BuildHIR)
-  var items = [1, 2, 3];
-
-  // Error: reading ref during render
-  const value = ref.current;
-
-  return (
-    <div>
-      {value}
-      {items.length}
-    </div>
-  );
-}

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/fbt/error.todo-fbt-as-local.expect.md

@@ -50,7 +50,7 @@ export const FIXTURE_ENTRYPOINT = {
 ## Error
 
 ```
-Found 4 errors:
+Found 1 error:
 
 Todo: Support local variables named `fbt`
 
@@ -60,49 +60,10 @@ error.todo-fbt-as-local.ts:18:19
   16 |
   17 | function Foo(props) {
 > 18 |   const getText1 = fbt =>
-     |                    ^^^ Support local variables named `fbt`
+     |                    ^^^ Rename to avoid conflict with fbt plugin
   19 |     fbt(
   20 |       `Hello, ${fbt.param('(key) name', identity(props.name))}!`,
   21 |       '(description) Greeting'
-
-Todo: Support local variables named `fbt`
-
-Local variables named `fbt` may conflict with the fbt plugin and are not yet supported.
-
-error.todo-fbt-as-local.ts:18:19
-  16 |
-  17 | function Foo(props) {
-> 18 |   const getText1 = fbt =>
-     |                    ^^^ Support local variables named `fbt`
-  19 |     fbt(
-  20 |       `Hello, ${fbt.param('(key) name', identity(props.name))}!`,
-  21 |       '(description) Greeting'
-
-Todo: Support local variables named `fbt`
-
-Local variables named `fbt` may conflict with the fbt plugin and are not yet supported.
-
-error.todo-fbt-as-local.ts:18:19
-  16 |
-  17 | function Foo(props) {
-> 18 |   const getText1 = fbt =>
-     |                    ^^^ Support local variables named `fbt`
-  19 |     fbt(
-  20 |       `Hello, ${fbt.param('(key) name', identity(props.name))}!`,
-  21 |       '(description) Greeting'
-
-Todo: Support local variables named `fbt`
-
-Local variables named `fbt` may conflict with the fbt plugin and are not yet supported.
-
-error.todo-fbt-as-local.ts:24:19
-  22 |     );
-  23 |
-> 24 |   const getText2 = fbt =>
-     |                    ^^^ Support local variables named `fbt`
-  25 |     fbt(
-  26 |       `Goodbye, ${fbt.param('(key) name', identity(props.name))}!`,
-  27 |       '(description) Greeting2'
 ```
           
       

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/fbt/error.todo-locally-require-fbt.expect.md

@@ -16,15 +16,17 @@ function Component(props) {
 ```
 Found 1 error:
 
-Invariant: <fbt> tags should be module-level imports
+Todo: Support local variables named `fbt`
 
-error.todo-locally-require-fbt.ts:4:10
-  2 |   const fbt = require('fbt');
+Local variables named `fbt` may conflict with the fbt plugin and are not yet supported.
+
+error.todo-locally-require-fbt.ts:2:8
+  1 | function Component(props) {
+> 2 |   const fbt = require('fbt');
+    |         ^^^ Rename to avoid conflict with fbt plugin
   3 |
-> 4 |   return <fbt desc="Description">{'Text'}</fbt>;
-    |           ^^^ <fbt> tags should be module-level imports
+  4 |   return <fbt desc="Description">{'Text'}</fbt>;
   5 | }
-  6 |
 ```
           
       

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/global-types/intl-datetimeformat.expect.md

@@ -1,62 +0,0 @@
-
-## Input
-
-```javascript
-function DateComponent({date}) {
-  const formatter = new Intl.DateTimeFormat('en-US');
-
-  return <time dateTime={date.toISOString()}>{formatter.format(date)}</time>;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: DateComponent,
-  params: [{date: new Date('2024-01-01')}],
-};
-
-```
-
-## Code
-
-```javascript
-import { c as _c } from "react/compiler-runtime";
-function DateComponent(t0) {
-  const $ = _c(6);
-  const { date } = t0;
-  let t1;
-  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
-    t1 = new Intl.DateTimeFormat("en-US");
-    $[0] = t1;
-  } else {
-    t1 = $[0];
-  }
-  const formatter = t1;
-  let t2;
-  if ($[1] !== date) {
-    t2 = date.toISOString();
-    $[1] = date;
-    $[2] = t2;
-  } else {
-    t2 = $[2];
-  }
-  const t3 = formatter.format(date);
-  let t4;
-  if ($[3] !== t2 || $[4] !== t3) {
-    t4 = <time dateTime={t2}>{t3}</time>;
-    $[3] = t2;
-    $[4] = t3;
-    $[5] = t4;
-  } else {
-    t4 = $[5];
-  }
-  return t4;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: DateComponent,
-  params: [{ date: new Date("2024-01-01") }],
-};
-
-```
-      
-### Eval output
-(kind: ok) <time datetime="2024-01-01T00:00:00.000Z">12/31/2023</time>

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/global-types/intl-datetimeformat.ts

@@ -1,10 +0,0 @@
-function DateComponent({date}) {
-  const formatter = new Intl.DateTimeFormat('en-US');
-
-  return <time dateTime={date.toISOString()}>{formatter.format(date)}</time>;
-}
-
-export const FIXTURE_ENTRYPOINT = {
-  fn: DateComponent,
-  params: [{date: new Date('2024-01-01')}],
-};

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/panresponder-ref-in-callback.expect.md

@@ -1,77 +0,0 @@
-
-## Input
-
-```javascript
-// @flow
-import {PanResponder, Stringify} from 'shared-runtime';
-
-export default component Playground() {
-  const onDragEndRef = useRef(() => {});
-  useEffect(() => {
-    onDragEndRef.current = () => {
-      console.log('drag ended');
-    };
-  });
-  const panResponder = useMemo(
-    () =>
-      PanResponder.create({
-        onPanResponderTerminate: () => {
-          onDragEndRef.current();
-        },
-      }),
-    []
-  );
-  return <Stringify responder={panResponder} />;
-}
-
-```
-
-## Code
-
-```javascript
-import { c as _c } from "react/compiler-runtime";
-import { PanResponder, Stringify } from "shared-runtime";
-
-export default function Playground() {
-  const $ = _c(3);
-  const onDragEndRef = useRef(_temp);
-  let t0;
-  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
-    t0 = () => {
-      onDragEndRef.current = _temp2;
-    };
-    $[0] = t0;
-  } else {
-    t0 = $[0];
-  }
-  useEffect(t0);
-  let t1;
-  if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
-    t1 = PanResponder.create({
-      onPanResponderTerminate: () => {
-        onDragEndRef.current();
-      },
-    });
-    $[1] = t1;
-  } else {
-    t1 = $[1];
-  }
-  const panResponder = t1;
-  let t2;
-  if ($[2] === Symbol.for("react.memo_cache_sentinel")) {
-    t2 = <Stringify responder={panResponder} />;
-    $[2] = t2;
-  } else {
-    t2 = $[2];
-  }
-  return t2;
-}
-function _temp2() {
-  console.log("drag ended");
-}
-function _temp() {}
-
-```
-      
-### Eval output
-(kind: exception) Fixture not implemented

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/panresponder-ref-in-callback.js

@@ -1,21 +0,0 @@
-// @flow
-import {PanResponder, Stringify} from 'shared-runtime';
-
-export default component Playground() {
-  const onDragEndRef = useRef(() => {});
-  useEffect(() => {
-    onDragEndRef.current = () => {
-      console.log('drag ended');
-    };
-  });
-  const panResponder = useMemo(
-    () =>
-      PanResponder.create({
-        onPanResponderTerminate: () => {
-          onDragEndRef.current();
-        },
-      }),
-    []
-  );
-  return <Stringify responder={panResponder} />;
-}

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/propagate-scope-deps-hir-fork/error.todo-optional-call-chain-in-optional.expect.md

@@ -0,0 +1,40 @@
+
+## Input
+
+```javascript
+// @enablePropagateDepsInHIR
+function useFoo(props: {value: {x: string; y: string} | null}) {
+  const value = props.value;
+  return createArray(value?.x, value?.y)?.join(', ');
+}
+
+function createArray<T>(...args: Array<T>): Array<T> {
+  return args;
+}
+
+export const FIXTURE_ENTRYPONT = {
+  fn: useFoo,
+  props: [{value: null}],
+};
+
+```
+
+
+## Error
+
+```
+Found 1 error:
+
+Todo: Unexpected terminal kind `optional` for optional fallthrough block
+
+error.todo-optional-call-chain-in-optional.ts:4:21
+  2 | function useFoo(props: {value: {x: string; y: string} | null}) {
+  3 |   const value = props.value;
+> 4 |   return createArray(value?.x, value?.y)?.join(', ');
+    |                      ^^^^^^^^ Unexpected terminal kind `optional` for optional fallthrough block
+  5 | }
+  6 |
+  7 | function createArray<T>(...args: Array<T>): Array<T> {
+```
+          
+      

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/propagate-scope-deps-hir-fork/todo-optional-call-chain-in-optional.expect.md

@@ -1,54 +0,0 @@
-
-## Input
-
-```javascript
-// @enablePropagateDepsInHIR
-function useFoo(props: {value: {x: string; y: string} | null}) {
-  const value = props.value;
-  return createArray(value?.x, value?.y)?.join(', ');
-}
-
-function createArray<T>(...args: Array<T>): Array<T> {
-  return args;
-}
-
-export const FIXTURE_ENTRYPONT = {
-  fn: useFoo,
-  props: [{value: null}],
-};
-
-```
-
-## Code
-
-```javascript
-import { c as _c } from "react/compiler-runtime"; // @enablePropagateDepsInHIR
-function useFoo(props) {
-  const $ = _c(3);
-  const value = props.value;
-  let t0;
-  if ($[0] !== value?.x || $[1] !== value?.y) {
-    t0 = createArray(value?.x, value?.y)?.join(", ");
-    $[0] = value?.x;
-    $[1] = value?.y;
-    $[2] = t0;
-  } else {
-    t0 = $[2];
-  }
-  return t0;
-}
-
-function createArray(...t0) {
-  const args = t0;
-  return args;
-}
-
-export const FIXTURE_ENTRYPONT = {
-  fn: useFoo,
-  props: [{ value: null }],
-};
-
-```
-      
-### Eval output
-(kind: exception) Fixture not implemented

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/todo-optional-call-chain-in-optional.expect.md

@@ -1,53 +0,0 @@
-
-## Input
-
-```javascript
-function useFoo(props: {value: {x: string; y: string} | null}) {
-  const value = props.value;
-  return createArray(value?.x, value?.y)?.join(', ');
-}
-
-function createArray<T>(...args: Array<T>): Array<T> {
-  return args;
-}
-
-export const FIXTURE_ENTRYPONT = {
-  fn: useFoo,
-  props: [{value: null}],
-};
-
-```
-
-## Code
-
-```javascript
-import { c as _c } from "react/compiler-runtime";
-function useFoo(props) {
-  const $ = _c(3);
-  const value = props.value;
-  let t0;
-  if ($[0] !== value?.x || $[1] !== value?.y) {
-    t0 = createArray(value?.x, value?.y)?.join(", ");
-    $[0] = value?.x;
-    $[1] = value?.y;
-    $[2] = t0;
-  } else {
-    t0 = $[2];
-  }
-  return t0;
-}
-
-function createArray(...t0) {
-  const args = t0;
-  return args;
-}
-
-export const FIXTURE_ENTRYPONT = {
-  fn: useFoo,
-  props: [{ value: null }],
-};
-
-```
-      
-### Eval output
-(kind: exception) Fixture not implemented

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/todo.error.object-pattern-computed-key.expect.md

@@ -23,18 +23,16 @@ export const FIXTURE_ENTRYPOINT = {
 ```
 Found 1 error:
 
-Invariant: [InferMutationAliasingEffects] Expected value kind to be initialized
+Todo: (BuildHIR::lowerAssignment) Handle computed properties in ObjectPattern
 
-<unknown> value$3.
-
-todo.error.object-pattern-computed-key.ts:6:9
+todo.error.object-pattern-computed-key.ts:5:9
+  3 | const SCALE = 2;
   4 | function Component(props) {
-  5 |   const {[props.name]: value} = props;
-> 6 |   return value;
-    |          ^^^^^ this is uninitialized
+> 5 |   const {[props.name]: value} = props;
+    |          ^^^^^^^^^^^^^^^^^^^ (BuildHIR::lowerAssignment) Handle computed properties in ObjectPattern
+  6 |   return value;
   7 | }
   8 |
-  9 | export const FIXTURE_ENTRYPOINT = {
 ```
           
       

compiler/packages/snap/src/compiler.ts

@@ -378,17 +378,6 @@ export async function transformFixtureInput(
       msg: 'Expected nothing to be compiled (from `// @expectNothingCompiled`), but some functions compiled or errored',
     };
   }
-  const unexpectedThrows = logs.filter(
-    log => log.event.kind === 'CompileUnexpectedThrow',
-  );
-  if (unexpectedThrows.length > 0) {
-    return {
-      kind: 'err',
-      msg:
-        `Compiler pass(es) threw instead of recording errors:\n` +
-        unexpectedThrows.map(l => (l.event as any).data).join('\n'),
-    };
-  }
   return {
     kind: 'ok',
     value: {

compiler/packages/snap/src/sprout/shared-runtime-type-provider.ts

@@ -196,44 +196,6 @@ export function makeSharedRuntimeTypeProvider({
               ],
             },
           },
-          PanResponder: {
-            kind: 'object',
-            properties: {
-              create: {
-                kind: 'function',
-                positionalParams: [EffectEnum.Freeze],
-                restParam: null,
-                calleeEffect: EffectEnum.Read,
-                returnType: {kind: 'type', name: 'Any'},
-                returnValueKind: ValueKindEnum.Frozen,
-                aliasing: {
-                  receiver: '@receiver',
-                  params: ['@config'],
-                  rest: null,
-                  returns: '@returns',
-                  temporaries: [],
-                  effects: [
-                    {
-                      kind: 'Freeze',
-                      value: '@config',
-                      reason: ValueReasonEnum.KnownReturnSignature,
-                    },
-                    {
-                      kind: 'Create',
-                      into: '@returns',
-                      value: ValueKindEnum.Frozen,
-                      reason: ValueReasonEnum.KnownReturnSignature,
-                    },
-                    {
-                      kind: 'ImmutableCapture',
-                      from: '@config',
-                      into: '@returns',
-                    },
-                  ],
-                },
-              },
-            },
-          },
         },
       };
     } else if (moduleName === 'ReactCompilerKnownIncompatibleTest') {

compiler/packages/snap/src/sprout/shared-runtime.ts

@@ -421,10 +421,4 @@ export function typedMutate(x: any, v: any = null): void {
   x.property = v;
 }
 
-export const PanResponder = {
-  create(obj: any): any {
-    return obj;
-  },
-};
-
 export default typedLog;

packages/react-devtools-core/README.md

@@ -54,7 +54,6 @@ Each filter object must include `type` and `isEnabled`. Some filters also requir
 |------------------------|---------------|---------------------------------------------------------------------------------------------------------------------------|
 | `host`                 | `"localhost"` | Socket connection to frontend should use this host.                                                                       |
 | `isAppActive`          |               | (Optional) function that returns true/false, telling DevTools when it's ready to connect to React.                        |
-| `path`                 | `""`          | Path appended to the WebSocket URI (e.g. `"/__react_devtools__/"`). Useful when proxying through a reverse proxy on a subpath. A leading `/` is added automatically if missing. |
 | `port`                 | `8097`        | Socket connection to frontend should use this port.                                                                       |
 | `resolveRNStyle`       |               | (Optional) function that accepts a key (number) and returns a style (object); used by React Native.                       |
 | `retryConnectionDelay` | `200`         | Delay (ms) to wait between retrying a failed Websocket connection                                                         |
@@ -142,51 +141,16 @@ function onStatus(
 }
 ```
 
-#### `startServer(port?, host?, httpsOptions?, loggerOptions?, path?, clientOptions?)`
+#### `startServer(port?: number, host?: string, httpsOptions?: Object, loggerOptions?: Object)`
 Start a socket server (used to communicate between backend and frontend) and renders the DevTools UI.
 
 This method accepts the following parameters:
 | Name | Default | Description |
 |---|---|---|
-| `port` | `8097` | Port the local server listens on. |
-| `host` | `"localhost"` | Host the local server binds to. |
+| `port` | `8097` | Socket connection to backend should use this port. |
+| `host` | `"localhost"` | Socket connection to backend should use this host. |
 | `httpsOptions` | | _Optional_ object defining `key` and `cert` strings. |
 | `loggerOptions` | | _Optional_ object defining a `surface` string (to be included with DevTools logging events). |
-| `path` | | _Optional_ path to append to the WebSocket URI served to connecting clients (e.g. `"/__react_devtools__/"`). Also set via the `REACT_DEVTOOLS_PATH` env var in the Electron app. |
-| `clientOptions` | | _Optional_ object with client-facing overrides (see below). |
-
-##### `clientOptions`
-
-When connecting through a reverse proxy, the client may need to connect to a different host, port, or protocol than the local server. Use `clientOptions` to override what appears in the `connectToDevTools()` script served to clients. Any field not set falls back to the corresponding server value.
-
-| Field | Default | Description |
-|---|---|---|
-| `host` | server `host` | Host the client connects to. |
-| `port` | server `port` | Port the client connects to. |
-| `useHttps` | server `useHttps` | Whether the client should use `wss://`. |
-
-These can also be set via environment variables in the Electron app:
-
-| Env Var | Description |
-|---|---|
-| `REACT_DEVTOOLS_CLIENT_HOST` | Overrides the host in the served client script. |
-| `REACT_DEVTOOLS_CLIENT_PORT` | Overrides the port in the served client script. |
-| `REACT_DEVTOOLS_CLIENT_USE_HTTPS` | Set to `"true"` to make the served client script use `wss://`. |
-
-##### Reverse proxy example
-
-Run DevTools locally on the default port, but tell clients to connect through a remote proxy:
-```sh
-REACT_DEVTOOLS_CLIENT_HOST=remote.example.com \
-REACT_DEVTOOLS_CLIENT_PORT=443 \
-REACT_DEVTOOLS_CLIENT_USE_HTTPS=true \
-REACT_DEVTOOLS_PATH=/__react_devtools__/ \
-react-devtools
-```
-The server listens on `localhost:8097`. The served script tells clients:
-```js
-connectToDevTools({host: 'remote.example.com', port: 443, useHttps: true, path: '/__react_devtools__/'})
-```
 
 # Development
 

packages/react-devtools-core/src/backend.js

@@ -33,7 +33,6 @@ import type {ResolveNativeStyle} from 'react-devtools-shared/src/backend/NativeS
 type ConnectOptions = {
   host?: string,
   nativeStyleEditorValidAttributes?: $ReadOnlyArray<string>,
-  path?: string,
   port?: number,
   useHttps?: boolean,
   resolveRNStyle?: ResolveNativeStyle,
@@ -94,7 +93,6 @@ export function connectToDevTools(options: ?ConnectOptions) {
   const {
     host = 'localhost',
     nativeStyleEditorValidAttributes,
-    path = '',
     useHttps = false,
     port = 8097,
     websocket,
@@ -109,7 +107,6 @@ export function connectToDevTools(options: ?ConnectOptions) {
   } = options || {};
 
   const protocol = useHttps ? 'wss' : 'ws';
-  const prefixedPath = path !== '' && !path.startsWith('/') ? '/' + path : path;
   let retryTimeoutID: TimeoutID | null = null;
 
   function scheduleRetry() {
@@ -132,7 +129,7 @@ export function connectToDevTools(options: ?ConnectOptions) {
   let bridge: BackendBridge | null = null;
 
   const messageListeners = [];
-  const uri = protocol + '://' + host + ':' + port + prefixedPath;
+  const uri = protocol + '://' + host + ':' + port;
 
   // If existing websocket is passed, use it.
   // This is necessary to support our custom integrations.

packages/react-devtools-core/src/standalone.js

@@ -306,19 +306,11 @@ type LoggerOptions = {
   surface?: ?string,
 };
 
-type ClientOptions = {
-  host?: string,
-  port?: number,
-  useHttps?: boolean,
-};
-
 function startServer(
   port: number = 8097,
   host: string = 'localhost',
   httpsOptions?: ServerOptions,
   loggerOptions?: LoggerOptions,
-  path?: string,
-  clientOptions?: ClientOptions,
 ): {close(): void} {
   registerDevToolsEventLogger(loggerOptions?.surface ?? 'standalone');
 
@@ -353,18 +345,7 @@ function startServer(
   server.on('error', (event: $FlowFixMe) => {
     onError(event);
     log.error('Failed to start the DevTools server', event);
-    startServerTimeoutID = setTimeout(
-      () =>
-        startServer(
-          port,
-          host,
-          httpsOptions,
-          loggerOptions,
-          path,
-          clientOptions,
-        ),
-      1000,
-    );
+    startServerTimeoutID = setTimeout(() => startServer(port), 1000);
   });
 
   httpServer.on('request', (request: $FlowFixMe, response: $FlowFixMe) => {
@@ -377,21 +358,14 @@ function startServer(
     // This will ensure that saved filters are shared across different web pages.
     const componentFiltersString = JSON.stringify(getSavedComponentFilters());
 
-    // Client overrides: when connecting through a reverse proxy, the client
-    // may need to connect to a different host/port/protocol than the server.
-    const clientHost = clientOptions?.host ?? host;
-    const clientPort = clientOptions?.port ?? port;
-    const clientUseHttps = clientOptions?.useHttps ?? useHttps;
-
     response.end(
       backendFile.toString() +
         '\n;' +
-        `var ReactDevToolsBackend = typeof ReactDevToolsBackend !== "undefined" ? ReactDevToolsBackend : require("ReactDevToolsBackend");\n` +
         `ReactDevToolsBackend.initialize(undefined, undefined, undefined, ${componentFiltersString});` +
         '\n' +
-        `ReactDevToolsBackend.connectToDevTools({port: ${clientPort}, host: '${clientHost}', useHttps: ${
-          clientUseHttps ? 'true' : 'false'
-        }${path != null ? `, path: '${path}'` : ''}});
+        `ReactDevToolsBackend.connectToDevTools({port: ${port}, host: '${host}', useHttps: ${
+          useHttps ? 'true' : 'false'
+        }});
         `,
     );
   });
@@ -399,18 +373,7 @@ function startServer(
   httpServer.on('error', (event: $FlowFixMe) => {
     onError(event);
     statusListener('Failed to start the server.', 'error');
-    startServerTimeoutID = setTimeout(
-      () =>
-        startServer(
-          port,
-          host,
-          httpsOptions,
-          loggerOptions,
-          path,
-          clientOptions,
-        ),
-      1000,
-    );
+    startServerTimeoutID = setTimeout(() => startServer(port), 1000);
   });
 
   httpServer.listen(port, () => {

packages/react-devtools-core/webpack.backend.js

@@ -44,7 +44,6 @@ module.exports = {
     // This name is important; standalone references it in order to connect.
     library: 'ReactDevToolsBackend',
     libraryTarget: 'umd',
-    umdNamedDefine: true,
   },
   resolve: {
     alias: {

packages/react-devtools/README.md

@@ -87,31 +87,7 @@ This will ensure the developer tools are connected. **Don’t forget to remove i
 
 ## Advanced
 
-By default DevTools listen to port `8097` on `localhost`. If you need to customize the server or client connection settings, the following environment variables are available:
-
-| Env Var | Default | Description |
-|---|---|---|
-| `HOST` | `"localhost"` | Host the local server binds to. |
-| `PORT` | `8097` | Port the local server listens on. |
-| `REACT_DEVTOOLS_PORT` | | Alias for `PORT`. Takes precedence if both are set. |
-| `KEY` | | Path to an SSL key file. Enables HTTPS when set alongside `CERT`. |
-| `CERT` | | Path to an SSL certificate file. Enables HTTPS when set alongside `KEY`. |
-| `REACT_DEVTOOLS_PATH` | | Path appended to the WebSocket URI served to clients (e.g. `/__react_devtools__/`). |
-| `REACT_DEVTOOLS_CLIENT_HOST` | `HOST` | Overrides the host in the script served to connecting clients. |
-| `REACT_DEVTOOLS_CLIENT_PORT` | `PORT` | Overrides the port in the script served to connecting clients. |
-| `REACT_DEVTOOLS_CLIENT_USE_HTTPS` | | Set to `"true"` to make the served client script use `wss://`. |
-
-When connecting through a reverse proxy, use the `REACT_DEVTOOLS_CLIENT_*` variables to tell clients to connect to a different host/port/protocol than the local server:
-
-```sh
-REACT_DEVTOOLS_CLIENT_HOST=remote.example.com \
-REACT_DEVTOOLS_CLIENT_PORT=443 \
-REACT_DEVTOOLS_CLIENT_USE_HTTPS=true \
-REACT_DEVTOOLS_PATH=/__react_devtools__/ \
-react-devtools
-```
-
-For more details, see the [`react-devtools-core` documentation](https://github.com/facebook/react/tree/main/packages/react-devtools-core).
+By default DevTools listen to port `8097` on `localhost`. The port can be modified by setting the `REACT_DEVTOOLS_PORT` environment variable. If you need to further customize host, port, or other settings, see the `react-devtools-core` package instead.
 
 ## FAQ
 

packages/react-devtools/app.html

@@ -158,19 +158,12 @@
     <script>
       // window.api is defined in preload.js
       const {electron, readEnv, ip, getDevTools} = window.api;
-      const {options, useHttps, host, protocol, port, path, clientHost, clientPort, clientUseHttps} = readEnv();
+      const {options, useHttps, host, protocol, port} = readEnv();
 
       const localIp = ip.address();
-
-      // Effective values for display URLs: client overrides take precedence over server values.
-      const effectiveHost = clientHost != null ? clientHost : host;
-      const effectivePort = clientPort != null ? clientPort : port;
-      const effectiveUseHttps = clientUseHttps != null ? clientUseHttps : useHttps;
-      const effectiveProtocol = effectiveUseHttps ? 'https' : 'http';
-      const defaultPort = (effectivePort === 443 && effectiveUseHttps) || (effectivePort === 80 && !effectiveUseHttps);
-      const pathStr = path != null ? path : '';
-      const server = defaultPort ? `${effectiveProtocol}://${effectiveHost}${pathStr}` : `${effectiveProtocol}://${effectiveHost}:${effectivePort}${pathStr}`;
-      const serverIp = defaultPort ? `${effectiveProtocol}://${localIp}${pathStr}` : `${effectiveProtocol}://${localIp}:${effectivePort}${pathStr}`;
+      const defaultPort = (port === 443 && useHttps) || (port === 80 && !useHttps);
+      const server = defaultPort ? `${protocol}://${host}` : `${protocol}://${host}:${port}`;
+      const serverIp = defaultPort ? `${protocol}://${localIp}` : `${protocol}://${localIp}:${port}`;
       const $ = document.querySelector.bind(document);
       
       let timeoutID;
@@ -241,7 +234,7 @@
             element.innerText = status;
           }
         })
-        .startServer(port, host, options, undefined, path, {host: clientHost, port: clientPort, useHttps: clientUseHttps});
+        .startServer(port, host, options);
     </script>
   </body>
 </html>

packages/react-devtools/preload.js

@@ -36,23 +36,6 @@ contextBridge.exposeInMainWorld('api', {
     const host = process.env.HOST || 'localhost';
     const protocol = useHttps ? 'https' : 'http';
     const port = +process.env.REACT_DEVTOOLS_PORT || +process.env.PORT || 8097;
-    const path = process.env.REACT_DEVTOOLS_PATH || undefined;
-    const clientHost = process.env.REACT_DEVTOOLS_CLIENT_HOST || undefined;
-    const clientPort = process.env.REACT_DEVTOOLS_CLIENT_PORT
-      ? +process.env.REACT_DEVTOOLS_CLIENT_PORT
-      : undefined;
-    const clientUseHttps =
-      process.env.REACT_DEVTOOLS_CLIENT_USE_HTTPS === 'true' ? true : undefined;
-    return {
-      options,
-      useHttps,
-      host,
-      protocol,
-      port,
-      path,
-      clientHost,
-      clientPort,
-      clientUseHttps,
-    };
+    return {options, useHttps, host, protocol, port};
   },
 });

packages/shared/ReactFeatureFlags.js

@@ -208,7 +208,7 @@ export const disableLegacyMode: boolean = true;
 // in open source, but www codebase still relies on it. Need to remove.
 export const disableCommentsAsDOMContainers: boolean = true;
 
-export const enableTrustedTypesIntegration: boolean = true;
+export const enableTrustedTypesIntegration: boolean = false;
 
 // Prevent the value and checked attributes from syncing with their related
 // DOM properties

packages/shared/forks/ReactFeatureFlags.native-fb.js

@@ -62,7 +62,7 @@ export const enableSuspenseAvoidThisFallback: boolean = false;
 export const enableSuspenseCallback: boolean = true;
 export const enableTaint: boolean = true;
 export const enableTransitionTracing: boolean = false;
-export const enableTrustedTypesIntegration: boolean = true;
+export const enableTrustedTypesIntegration: boolean = false;
 export const enableUpdaterTracking: boolean = __PROFILE__;
 export const retryLaneExpirationMs = 5000;
 export const syncLaneExpirationMs = 250;

packages/shared/forks/ReactFeatureFlags.native-oss.js

@@ -50,7 +50,7 @@ export const enableSuspenseAvoidThisFallback: boolean = false;
 export const enableSuspenseCallback: boolean = false;
 export const enableTaint: boolean = true;
 export const enableTransitionTracing: boolean = false;
-export const enableTrustedTypesIntegration: boolean = true;
+export const enableTrustedTypesIntegration: boolean = false;
 export const passChildrenWhenCloningPersistedNodes: boolean = false;
 export const retryLaneExpirationMs = 5000;
 export const syncLaneExpirationMs = 250;

packages/shared/forks/ReactFeatureFlags.test-renderer.js

@@ -26,7 +26,7 @@ export const disableInputAttributeSyncing: boolean = false;
 export const enableScopeAPI: boolean = false;
 export const enableCreateEventHandleAPI: boolean = false;
 export const enableSuspenseCallback: boolean = false;
-export const enableTrustedTypesIntegration: boolean = true;
+export const enableTrustedTypesIntegration: boolean = false;
 export const disableTextareaChildren: boolean = false;
 export const enableSuspenseAvoidThisFallback: boolean = false;
 export const enableCPUSuspense: boolean = false;

packages/shared/forks/ReactFeatureFlags.test-renderer.native-fb.js

@@ -47,7 +47,7 @@ export const enableSuspenseAvoidThisFallback = false;
 export const enableSuspenseCallback = false;
 export const enableTaint = true;
 export const enableTransitionTracing = false;
-export const enableTrustedTypesIntegration = true;
+export const enableTrustedTypesIntegration = false;
 export const enableUpdaterTracking = false;
 export const passChildrenWhenCloningPersistedNodes = false;
 export const retryLaneExpirationMs = 5000;

packages/shared/forks/ReactFeatureFlags.test-renderer.www.js

@@ -28,7 +28,7 @@ export const enableCreateEventHandleAPI: boolean = false;
 export const enableSuspenseCallback: boolean = true;
 export const disableLegacyContext: boolean = false;
 export const disableLegacyContextForFunctionComponents: boolean = false;
-export const enableTrustedTypesIntegration: boolean = true;
+export const enableTrustedTypesIntegration: boolean = false;
 export const disableTextareaChildren: boolean = false;
 export const enableSuspenseAvoidThisFallback: boolean = true;
 export const enableCPUSuspense: boolean = false;

packages/shared/forks/ReactFeatureFlags.www-dynamic.js

@@ -36,6 +36,7 @@ export const enableFragmentRefs: boolean = __VARIANT__;
 export const enableFragmentRefsScrollIntoView: boolean = __VARIANT__;
 export const enableFragmentRefsTextNodes: boolean = __VARIANT__;
 export const enableInternalInstanceMap: boolean = __VARIANT__;
+export const enableTrustedTypesIntegration: boolean = __VARIANT__;
 export const enableParallelTransitions: boolean = __VARIANT__;
 
 export const enableEffectEventMutationPhase: boolean = __VARIANT__;

packages/shared/forks/ReactFeatureFlags.www.js

@@ -25,6 +25,7 @@ export const {
   enableObjectFiber,
   enableRetryLaneExpiration,
   enableTransitionTracing,
+  enableTrustedTypesIntegration,
   retryLaneExpirationMs,
   syncLaneExpirationMs,
   transitionLaneExpirationMs,
@@ -44,7 +45,7 @@ export const enableProfilerTimer = __PROFILE__;
 export const enableProfilerCommitHooks = __PROFILE__;
 export const enableProfilerNestedUpdatePhase = __PROFILE__;
 export const enableUpdaterTracking = __PROFILE__;
-export const enableTrustedTypesIntegration: boolean = true;
+
 export const enableSuspenseAvoidThisFallback: boolean = true;
 
 export const enableAsyncDebugInfo: boolean = true;