[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/fault-tolerance-overview.md

@@ -75,49 +75,49 @@ Change `runWithEnvironment` to run all passes and check for errors at the end in
 
 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.
 
-- [x] **3.1 Change `lower` to always return HIRFunction** (`src/HIR/BuildHIR.ts`)
+- [ ] **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.recordErrors(builder.errors)` and return the (partial) HIR
+  - 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()`
-  - Added try/catch around body lowering to catch thrown CompilerErrors (e.g., from `resolveBinding`) and record them
 
-- [x] **3.2 Handle `var` declarations as `let`** (`src/HIR/BuildHIR.ts`, line ~855)
-  - Record the Todo error, then treat `var` as `let` and continue lowering (instead of skipping the declaration)
+- [ ] **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
 
-- [x] **3.3 Handle `try/finally` by pruning `finally`** (`src/HIR/BuildHIR.ts`, lines ~1281-1296)
-  - Already handled: `try` without `catch` pushes error and returns; `try` with `finally` pushes error and continues with `try/catch` portion only
+- [ ] **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)
 
-- [x] **3.4 Handle `eval()` via UnsupportedNode** (`src/HIR/BuildHIR.ts`, line ~3568)
-  - Already handled: records error via `builder.errors.push()` and continues
+- [ ] **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
 
-- [x] **3.5 Handle `with` statement via UnsupportedNode** (`src/HIR/BuildHIR.ts`, line ~1382)
-  - Already handled: records error and emits `UnsupportedNode`
+- [ ] **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
 
-- [x] **3.6 Handle inline `class` declarations** (`src/HIR/BuildHIR.ts`, line ~1402)
-  - Already handled: records error and emits `UnsupportedNode`
+- [ ] **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
 
-- [x] **3.7 Handle remaining Todo errors in expression lowering** (`src/HIR/BuildHIR.ts`)
-  - Already handled: all ~60 error sites use `builder.errors.push()` to accumulate errors. The try/catch around body lowering provides a safety net for any that still throw.
+- [ ] **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
 
-- [x] **3.8 Handle `throw` inside `try/catch`** (`src/HIR/BuildHIR.ts`, line ~284)
-  - Already handled: records error via `builder.errors.push()` and continues
+- [ ] **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`)
 
-- [x] **3.9 Handle `for` loops with missing test or expression init** (`src/HIR/BuildHIR.ts`, lines ~559, ~632)
-  - For `for(;;)` (missing test): emit `true` as the test expression and add a branch terminal
-  - For empty init (`for (; ...)`): add a placeholder instruction to avoid invariant about empty blocks
-  - For expression init (`for (expr; ...)`): record error and lower the expression as best-effort
-  - Changed `'unsupported'` terminal to `'goto'` terminal for non-variable init to maintain valid CFG structure
+- [ ] **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)
 
-- [x] **3.10 Handle nested function lowering failures** (`src/HIR/BuildHIR.ts`, `lowerFunction` at line ~3504)
-  - `lowerFunction()` now always returns `LoweredFunction` since `lower()` always returns `HIRFunction`
-  - Errors from nested functions are recorded on the shared environment
-  - Removed the `null` return case and the corresponding `UnsupportedNode` fallback in callers
-
-- [x] **3.11 Handle unreachable functions in `build()`** (`src/HIR/HIRBuilder.ts`, `build()`)
-  - Changed `CompilerError.throwTodo()` for unreachable code with hoisted declarations to `this.errors.push()` to allow HIR construction to complete
-
-- [x] **3.12 Handle duplicate fbt tags** (`src/HIR/BuildHIR.ts`, line ~2279)
-  - Changed `CompilerError.throwDiagnostic()` to `builder.errors.pushDiagnostic()` to record instead of throw
+- [ ] **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
 
@@ -174,17 +174,17 @@ These passes already accumulate errors internally and return `Result<void, Compi
   - Record errors on env
   - Update Pipeline.ts call site (line 315): remove `.unwrap()`
 
-- [x] **4.10 `validateMemoizedEffectDependencies`** (`src/Validation/ValidateMemoizedEffectDependencies.ts`)
+- [ ] **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()`
 
-- [x] **4.11 `validatePreservedManualMemoization`** (`src/Validation/ValidatePreservedManualMemoization.ts`)
+- [ ] **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()`
 
-- [x] **4.12 `validateSourceLocations`** (`src/Validation/ValidateSourceLocations.ts`)
+- [ ] **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()`
@@ -202,16 +202,16 @@ These already use a soft-logging pattern and don't block compilation. They can b
 
 These throw `CompilerError` directly (not via Result). They need the most work.
 
-- [x] **4.17 `validateContextVariableLValues`** (`src/Validation/ValidateContextVariableLValues.ts`)
+- [ ] **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)
 
-- [x] **4.18 `validateLocalsNotReassignedAfterRender`** (`src/Validation/ValidateLocalsNotReassignedAfterRender.ts`)
+- [ ] **4.18 `validateLocalsNotReassignedAfterRender`** (`src/Validation/ValidateLocalsNotReassignedAfterRender.ts`)
   - Currently constructs a `CompilerError` and `throw`s it directly
   - Change to record errors on env
 
-- [x] **4.19 `validateNoDerivedComputationsInEffects`** (`src/Validation/ValidateNoDerivedComputationsInEffects.ts`)
+- [ ] **4.19 `validateNoDerivedComputationsInEffects`** (`src/Validation/ValidateNoDerivedComputationsInEffects.ts`)
   - Currently throws directly
   - Change to record errors on env
 
@@ -219,14 +219,14 @@ These throw `CompilerError` directly (not via Result). They need the most work.
 
 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.
 
-- [x] **5.1 `inferMutationAliasingEffects`** (`src/Inference/InferMutationAliasingEffects.ts`)
+- [ ] **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
 
-- [x] **5.2 `inferMutationAliasingRanges`** (`src/Inference/InferMutationAliasingRanges.ts`)
+- [ ] **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
@@ -235,7 +235,7 @@ The inference passes are the most critical to handle correctly because they prod
 
 ### Phase 6: Update Codegen
 
-- [x] **6.1 `codegenFunction`** (`src/ReactiveScopes/CodegenReactiveFunction.ts`)
+- [ ] **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:
@@ -279,27 +279,27 @@ Walk through `runWithEnvironment` and wrap each pass call site. This is the inte
 
 ### Phase 8: Testing
 
-- [x] **8.1 Update existing `error.todo-*` fixture expectations**
+- [ ] **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
 
-- [x] **8.2 Add multi-error test fixtures**
+- [ ] **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
 
-- [x] **8.3 Add test for invariant-still-throws behavior**
+- [ ] **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
 
-- [x] **8.4 Add test for partial HIR codegen**
+- [ ] **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
 
-- [x] **8.5 Verify error severity in aggregated output**
+- [ ] **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
 
-- [x] **8.6 Run full test suite**
+- [ ] **8.6 Run full test suite**
   - Run `yarn snap` and `yarn snap -u` to update all fixture expectations
   - Ensure no regressions in passing tests
 
@@ -324,10 +324,4 @@ Walk through `runWithEnvironment` and wrap each pass call site. This is the inte
 * **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.
-* **Phase 3 (BuildHIR) revealed that most error sites already used `builder.errors.push()` for accumulation.** The existing lowering code was designed to accumulate errors rather than throw. The main changes were: (1) changing `lower()` return type from `Result` to `HIRFunction`, (2) recording builder errors on env, (3) adding a try/catch around body lowering to catch thrown CompilerErrors from sub-calls like `resolveBinding()`, (4) treating `var` as `let` instead of skipping declarations, and (5) fixing ForStatement init/test handling to produce valid CFG structure.
-* **Partial HIR can trigger downstream invariants.** When lowering skips or partially handles constructs (e.g., unreachable hoisted functions, `var` declarations before the fix), downstream passes like `InferMutationAliasingEffects` may encounter uninitialized identifiers and throw invariants. This is acceptable since the function still correctly bails out of compilation, but error messages may be less specific. The fix for `var` (treating as `let`) demonstrates how to avoid this: continue lowering with a best-effort representation rather than skipping entirely.
-* **Errors accumulated on `env` are lost when an invariant propagates out of the pipeline.** Since invariant CompilerErrors always re-throw through `tryRecord()`, they exit the pipeline as exceptions. The caller only sees the invariant error, not any errors previously recorded on `env`. This is a design limitation that could be addressed by aggregating env errors with caught exceptions in `tryCompileFunction()`.
-* **Dedicated fault tolerance test fixtures** were added in `__tests__/fixtures/compiler/fault-tolerance/`. Each fixture combines two or more errors from different passes to verify the compiler reports all of them rather than short-circuiting on the first. Coverage includes: `var`+props mutation (BuildHIR→InferMutationAliasingEffects), `var`+ref access (BuildHIR→ValidateNoRefAccessInRender), `try/finally`+props mutation (BuildHIR→InferMutationAliasingEffects), `try/finally`+ref access (BuildHIR→ValidateNoRefAccessInRender), and a 3-error test combining try/finally+ref access+props mutation.
-* **Cleanup: consistent `tryRecord()` wrapping in Pipeline.ts.** All validation passes and inference passes are now wrapped in `env.tryRecord()` for defense-in-depth, consistent with the approach used for transform passes. Previously only transform passes were wrapped. Merged duplicate `env.enableValidations` guard blocks. Pattern B lint-only passes (`env.logErrors()`) were intentionally not wrapped since they use a different error recording strategy.
-* **Cleanup: normalized validation error recording pattern.** Four validation passes (`ValidateNoDerivedComputationsInEffects`, `ValidateMemoizedEffectDependencies`, `ValidatePreservedManualMemoization`, `ValidateSourceLocations`) were using `for (const detail of errors.details) { env.recordError(detail); }` instead of the simpler `env.recordErrors(errors)`. Normalized to use the batch method.
 

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

@@ -254,7 +254,6 @@ export type LoggerEvent =
   | CompileErrorEvent
   | CompileDiagnosticEvent
   | CompileSkipEvent
-  | CompileUnexpectedThrowEvent
   | PipelineErrorEvent
   | TimingEvent;
 
@@ -289,11 +288,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,
@@ -155,13 +156,17 @@ 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);
+  env.tryRecord(() => {
+    pruneMaybeThrows(hir);
+  });
   log({kind: 'hir', name: 'PruneMaybeThrows', value: hir});
 
-  validateContextVariableLValues(hir);
+  env.tryRecord(() => {
+    validateContextVariableLValues(hir);
+  });
   validateUseMemo(hir);
 
   if (env.enableDropManualMemoization) {
@@ -169,31 +174,43 @@ function runWithEnvironment(
     log({kind: 'hir', name: 'DropManualMemoization', value: hir});
   }
 
-  inlineImmediatelyInvokedFunctionExpressions(hir);
+  env.tryRecord(() => {
+    inlineImmediatelyInvokedFunctionExpressions(hir);
+  });
   log({
     kind: 'hir',
     name: 'InlineImmediatelyInvokedFunctionExpressions',
     value: hir,
   });
 
-  mergeConsecutiveBlocks(hir);
+  env.tryRecord(() => {
+    mergeConsecutiveBlocks(hir);
+  });
   log({kind: 'hir', name: 'MergeConsecutiveBlocks', value: hir});
 
   assertConsistentIdentifiers(hir);
   assertTerminalSuccessorsExist(hir);
 
-  enterSSA(hir);
+  env.tryRecord(() => {
+    enterSSA(hir);
+  });
   log({kind: 'hir', name: 'SSA', value: hir});
 
-  eliminateRedundantPhi(hir);
+  env.tryRecord(() => {
+    eliminateRedundantPhi(hir);
+  });
   log({kind: 'hir', name: 'EliminateRedundantPhi', value: hir});
 
   assertConsistentIdentifiers(hir);
 
-  constantPropagation(hir);
+  env.tryRecord(() => {
+    constantPropagation(hir);
+  });
   log({kind: 'hir', name: 'ConstantPropagation', value: hir});
 
-  inferTypes(hir);
+  env.tryRecord(() => {
+    inferTypes(hir);
+  });
   log({kind: 'hir', name: 'InferTypes', value: hir});
 
   if (env.enableValidations) {
@@ -205,33 +222,55 @@ function runWithEnvironment(
     }
   }
 
-  optimizePropsMethodCalls(hir);
+  env.tryRecord(() => {
+    optimizePropsMethodCalls(hir);
+  });
   log({kind: 'hir', name: 'OptimizePropsMethodCalls', value: hir});
 
-  analyseFunctions(hir);
+  env.tryRecord(() => {
+    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);
+    env.tryRecord(() => {
+      optimizeForSSR(hir);
+    });
     log({kind: 'hir', name: 'OptimizeForSSR', value: hir});
   }
 
   // Note: Has to come after infer reference effects because "dead" code may still affect inference
-  deadCodeElimination(hir);
+  env.tryRecord(() => {
+    deadCodeElimination(hir);
+  });
   log({kind: 'hir', name: 'DeadCodeElimination', value: hir});
-  pruneMaybeThrows(hir);
+  env.tryRecord(() => {
+    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);
     }
@@ -250,7 +289,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') {
@@ -268,7 +309,9 @@ function runWithEnvironment(
     validateNoFreezingKnownMutableFunctions(hir);
   }
 
-  inferReactivePlaces(hir);
+  env.tryRecord(() => {
+    inferReactivePlaces(hir);
+  });
   log({kind: 'hir', name: 'InferReactivePlaces', value: hir});
 
   if (env.enableValidations) {
@@ -281,7 +324,9 @@ function runWithEnvironment(
     }
   }
 
-  rewriteInstructionKindsBasedOnReassignment(hir);
+  env.tryRecord(() => {
+    rewriteInstructionKindsBasedOnReassignment(hir);
+  });
   log({
     kind: 'hir',
     name: 'RewriteInstructionKindsBasedOnReassignment',
@@ -302,11 +347,16 @@ function runWithEnvironment(
      * if inferred memoization is enabled. This makes all later passes which
      * transform reactive-scope labeled instructions no-ops.
      */
-    inferReactiveScopeVariables(hir);
+    env.tryRecord(() => {
+      inferReactiveScopeVariables(hir);
+    });
     log({kind: 'hir', name: 'InferReactiveScopeVariables', value: hir});
   }
 
-  const fbtOperands = memoizeFbtAndMacroOperandsInSameScope(hir);
+  let fbtOperands: Set<IdentifierId> = new Set();
+  env.tryRecord(() => {
+    fbtOperands = memoizeFbtAndMacroOperandsInSameScope(hir);
+  });
   log({
     kind: 'hir',
     name: 'MemoizeFbtAndMacroOperandsInSameScope',
@@ -314,11 +364,15 @@ function runWithEnvironment(
   });
 
   if (env.config.enableJsxOutlining) {
-    outlineJSX(hir);
+    env.tryRecord(() => {
+      outlineJSX(hir);
+    });
   }
 
   if (env.config.enableNameAnonymousFunctions) {
-    nameAnonymousFunctions(hir);
+    env.tryRecord(() => {
+      nameAnonymousFunctions(hir);
+    });
     log({
       kind: 'hir',
       name: 'NameAnonymousFunctions',
@@ -327,39 +381,51 @@ function runWithEnvironment(
   }
 
   if (env.config.enableFunctionOutlining) {
-    outlineFunctions(hir, fbtOperands);
+    env.tryRecord(() => {
+      outlineFunctions(hir, fbtOperands);
+    });
     log({kind: 'hir', name: 'OutlineFunctions', value: hir});
   }
 
-  alignMethodCallScopes(hir);
+  env.tryRecord(() => {
+    alignMethodCallScopes(hir);
+  });
   log({
     kind: 'hir',
     name: 'AlignMethodCallScopes',
     value: hir,
   });
 
-  alignObjectMethodScopes(hir);
+  env.tryRecord(() => {
+    alignObjectMethodScopes(hir);
+  });
   log({
     kind: 'hir',
     name: 'AlignObjectMethodScopes',
     value: hir,
   });
 
-  pruneUnusedLabelsHIR(hir);
+  env.tryRecord(() => {
+    pruneUnusedLabelsHIR(hir);
+  });
   log({
     kind: 'hir',
     name: 'PruneUnusedLabelsHIR',
     value: hir,
   });
 
-  alignReactiveScopesToBlockScopesHIR(hir);
+  env.tryRecord(() => {
+    alignReactiveScopesToBlockScopesHIR(hir);
+  });
   log({
     kind: 'hir',
     name: 'AlignReactiveScopesToBlockScopesHIR',
     value: hir,
   });
 
-  mergeOverlappingReactiveScopesHIR(hir);
+  env.tryRecord(() => {
+    mergeOverlappingReactiveScopesHIR(hir);
+  });
   log({
     kind: 'hir',
     name: 'MergeOverlappingReactiveScopesHIR',
@@ -367,7 +433,9 @@ function runWithEnvironment(
   });
   assertValidBlockNesting(hir);
 
-  buildReactiveScopeTerminalsHIR(hir);
+  env.tryRecord(() => {
+    buildReactiveScopeTerminalsHIR(hir);
+  });
   log({
     kind: 'hir',
     name: 'BuildReactiveScopeTerminalsHIR',
@@ -376,14 +444,18 @@ function runWithEnvironment(
 
   assertValidBlockNesting(hir);
 
-  flattenReactiveLoopsHIR(hir);
+  env.tryRecord(() => {
+    flattenReactiveLoopsHIR(hir);
+  });
   log({
     kind: 'hir',
     name: 'FlattenReactiveLoopsHIR',
     value: hir,
   });
 
-  flattenScopesWithHooksOrUseHIR(hir);
+  env.tryRecord(() => {
+    flattenScopesWithHooksOrUseHIR(hir);
+  });
   log({
     kind: 'hir',
     name: 'FlattenScopesWithHooksOrUseHIR',
@@ -391,15 +463,19 @@ function runWithEnvironment(
   });
   assertTerminalSuccessorsExist(hir);
   assertTerminalPredsExist(hir);
-
-  propagateScopeDependenciesHIR(hir);
+  env.tryRecord(() => {
+    propagateScopeDependenciesHIR(hir);
+  });
   log({
     kind: 'hir',
     name: 'PropagateScopeDependenciesHIR',
     value: hir,
   });
 
-  const reactiveFunction = buildReactiveFunction(hir);
+  let reactiveFunction!: ReactiveFunction;
+  env.tryRecord(() => {
+    reactiveFunction = buildReactiveFunction(hir);
+  });
   log({
     kind: 'reactive',
     name: 'BuildReactiveFunction',
@@ -408,7 +484,9 @@ function runWithEnvironment(
 
   assertWellFormedBreakTargets(reactiveFunction);
 
-  pruneUnusedLabels(reactiveFunction);
+  env.tryRecord(() => {
+    pruneUnusedLabels(reactiveFunction);
+  });
   log({
     kind: 'reactive',
     name: 'PruneUnusedLabels',
@@ -416,84 +494,109 @@ function runWithEnvironment(
   });
   assertScopeInstructionsWithinScopes(reactiveFunction);
 
-  pruneNonEscapingScopes(reactiveFunction);
+  env.tryRecord(() => {
+    pruneNonEscapingScopes(reactiveFunction);
+  });
   log({
     kind: 'reactive',
     name: 'PruneNonEscapingScopes',
     value: reactiveFunction,
   });
 
-  pruneNonReactiveDependencies(reactiveFunction);
+  env.tryRecord(() => {
+    pruneNonReactiveDependencies(reactiveFunction);
+  });
   log({
     kind: 'reactive',
     name: 'PruneNonReactiveDependencies',
     value: reactiveFunction,
   });
 
-  pruneUnusedScopes(reactiveFunction);
+  env.tryRecord(() => {
+    pruneUnusedScopes(reactiveFunction);
+  });
   log({
     kind: 'reactive',
     name: 'PruneUnusedScopes',
     value: reactiveFunction,
   });
 
-  mergeReactiveScopesThatInvalidateTogether(reactiveFunction);
+  env.tryRecord(() => {
+    mergeReactiveScopesThatInvalidateTogether(reactiveFunction);
+  });
   log({
     kind: 'reactive',
     name: 'MergeReactiveScopesThatInvalidateTogether',
     value: reactiveFunction,
   });
 
-  pruneAlwaysInvalidatingScopes(reactiveFunction);
+  env.tryRecord(() => {
+    pruneAlwaysInvalidatingScopes(reactiveFunction);
+  });
   log({
     kind: 'reactive',
     name: 'PruneAlwaysInvalidatingScopes',
     value: reactiveFunction,
   });
 
-  propagateEarlyReturns(reactiveFunction);
+  env.tryRecord(() => {
+    propagateEarlyReturns(reactiveFunction);
+  });
   log({
     kind: 'reactive',
     name: 'PropagateEarlyReturns',
     value: reactiveFunction,
   });
 
-  pruneUnusedLValues(reactiveFunction);
+  env.tryRecord(() => {
+    pruneUnusedLValues(reactiveFunction);
+  });
   log({
     kind: 'reactive',
     name: 'PruneUnusedLValues',
     value: reactiveFunction,
   });
 
-  promoteUsedTemporaries(reactiveFunction);
+  env.tryRecord(() => {
+    promoteUsedTemporaries(reactiveFunction);
+  });
   log({
     kind: 'reactive',
     name: 'PromoteUsedTemporaries',
     value: reactiveFunction,
   });
 
-  extractScopeDeclarationsFromDestructuring(reactiveFunction);
+  env.tryRecord(() => {
+    extractScopeDeclarationsFromDestructuring(reactiveFunction);
+  });
   log({
     kind: 'reactive',
     name: 'ExtractScopeDeclarationsFromDestructuring',
     value: reactiveFunction,
   });
 
-  stabilizeBlockIds(reactiveFunction);
+  env.tryRecord(() => {
+    stabilizeBlockIds(reactiveFunction);
+  });
   log({
     kind: 'reactive',
     name: 'StabilizeBlockIds',
     value: reactiveFunction,
   });
 
-  const uniqueIdentifiers = renameVariables(reactiveFunction);
+  let uniqueIdentifiers: Set<string> = new Set();
+  env.tryRecord(() => {
+    uniqueIdentifiers = renameVariables(reactiveFunction);
+  });
   log({
     kind: 'reactive',
     name: 'RenameVariables',
     value: reactiveFunction,
   });
 
-  pruneHoistedContexts(reactiveFunction);
+  env.tryRecord(() => {
+    pruneHoistedContexts(reactiveFunction);
+  });
   log({
     kind: 'reactive',
     name: 'PruneHoistedContexts',
@@ -505,20 +608,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

@@ -720,25 +720,10 @@ 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};
   }
 }
 
-
 /**
  * Applies React Compiler generated functions to the babel AST by replacing
  * existing functions in place or inserting new declarations.

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

@@ -14,6 +14,7 @@ import {
   CompilerSuggestionOperation,
   ErrorCategory,
 } from '../CompilerError';
+import {Err, Ok, Result} from '../Utils/Result';
 import {assertExhaustive, hasNode} from '../Utils/utils';
 import {Environment} from './Environment';
 import {
@@ -74,7 +75,7 @@ export function lower(
   // Bindings captured from the outer function, in case lower() is called recursively (for lambdas)
   bindings: Bindings | null = null,
   capturedRefs: Map<t.Identifier, SourceLocation> = new Map(),
-): HIRFunction {
+): Result<HIRFunction, CompilerError> {
   const builder = new HIRBuilder(env, {
     bindings,
     context: capturedRefs,
@@ -223,6 +224,10 @@ export function lower(
     }
   }
 
+  if (builder.errors.hasAnyErrors()) {
+    return Err(builder.errors);
+  }
+
   builder.terminate(
     {
       kind: 'return',
@@ -239,29 +244,23 @@ export function lower(
     null,
   );
 
-  const hirBody = builder.build();
-
-  // Record all accumulated errors (including any from build()) on env
-  if (builder.errors.hasAnyErrors()) {
-    env.recordErrors(builder.errors);
-  }
-
-  return {
+  return Ok({
     id: validatedId,
     nameHint: null,
     params,
     fnType: bindings == null ? env.fnType : 'Other',
     returnTypeAnnotation: null, // TODO: extract the actual return type node if present
     returns: createTemporaryPlace(env, func.node.loc ?? GeneratedSource),
-    body: hirBody,
+    body: builder.build(),
     context,
     generator: func.node.generator === true,
     async: func.node.async === true,
     loc: func.node.loc ?? GeneratedSource,
     env,
+    effects: null,
     aliasingEffects: null,
     directives,
-  };
+  });
 }
 
 // Helper to lower a statement
@@ -556,22 +555,6 @@ function lowerStatement(
 
       const initBlock = builder.enter('loop', _blockId => {
         const init = stmt.get('init');
-        if (init.node == null) {
-          // No init expression (e.g., `for (; ...)`), add a placeholder to avoid
-          // invariant about empty blocks
-          lowerValueToTemporary(builder, {
-            kind: 'Primitive',
-            value: undefined,
-            loc: stmt.node.loc ?? GeneratedSource,
-          });
-          return {
-            kind: 'goto',
-            block: testBlock.id,
-            variant: GotoVariant.Break,
-            id: makeInstructionId(0),
-            loc: stmt.node.loc ?? GeneratedSource,
-          };
-        }
         if (!init.isVariableDeclaration()) {
           builder.errors.push({
             reason:
@@ -580,14 +563,8 @@ function lowerStatement(
             loc: stmt.node.loc ?? null,
             suggestions: null,
           });
-          // Lower the init expression as best-effort and continue
-          if (init.isExpression()) {
-            lowerExpressionToTemporary(builder, init as NodePath<t.Expression>);
-          }
           return {
-            kind: 'goto',
-            block: testBlock.id,
-            variant: GotoVariant.Break,
+            kind: 'unsupported',
             id: makeInstructionId(0),
             loc: init.node?.loc ?? GeneratedSource,
           };
@@ -658,23 +635,6 @@ function lowerStatement(
           loc: stmt.node.loc ?? null,
           suggestions: null,
         });
-        // Treat `for(;;)` as `while(true)` to keep the builder state consistent
-        builder.terminateWithContinuation(
-          {
-            kind: 'branch',
-            test: lowerValueToTemporary(builder, {
-              kind: 'Primitive',
-              value: true,
-              loc: stmt.node.loc ?? GeneratedSource,
-            }),
-            consequent: bodyBlock,
-            alternate: continuationBlock.id,
-            fallthrough: continuationBlock.id,
-            id: makeInstructionId(0),
-            loc: stmt.node.loc ?? GeneratedSource,
-          },
-          continuationBlock,
-        );
       } else {
         builder.terminateWithContinuation(
           {
@@ -898,12 +858,10 @@ function lowerStatement(
           loc: stmt.node.loc ?? null,
           suggestions: null,
         });
-        // Treat `var` as `let` so references to the variable don't break
+        return;
       }
       const kind =
-        nodeKind === 'let' || nodeKind === 'var'
-          ? InstructionKind.Let
-          : InstructionKind.Const;
+        nodeKind === 'let' ? InstructionKind.Let : InstructionKind.Const;
       for (const declaration of stmt.get('declarations')) {
         const id = declaration.get('id');
         const init = declaration.get('init');
@@ -1536,6 +1494,9 @@ function lowerObjectMethod(
 ): InstructionValue {
   const loc = property.node.loc ?? GeneratedSource;
   const loweredFunc = lowerFunction(builder, property);
+  if (!loweredFunc) {
+    return {kind: 'UnsupportedNode', node: property.node, loc: loc};
+  }
 
   return {
     kind: 'ObjectMethod',
@@ -2315,20 +2276,18 @@ function lowerExpression(
         });
         for (const [name, locations] of Object.entries(fbtLocations)) {
           if (locations.length > 1) {
-            builder.errors.pushDiagnostic(
-              new CompilerDiagnostic({
-                category: ErrorCategory.Todo,
-                reason: 'Support duplicate fbt tags',
-                description: `Support \`<${tagName}>\` tags with multiple \`<${tagName}:${name}>\` values`,
-                details: locations.map(loc => {
-                  return {
-                    kind: 'error' as const,
-                    message: `Multiple \`<${tagName}:${name}>\` tags found`,
-                    loc,
-                  };
-                }),
+            CompilerError.throwDiagnostic({
+              category: ErrorCategory.Todo,
+              reason: 'Support duplicate fbt tags',
+              description: `Support \`<${tagName}>\` tags with multiple \`<${tagName}:${name}>\` values`,
+              details: locations.map(loc => {
+                return {
+                  kind: 'error',
+                  message: `Multiple \`<${tagName}:${name}>\` tags found`,
+                  loc,
+                };
               }),
-            );
+            });
           }
         }
       }
@@ -3509,6 +3468,9 @@ function lowerFunctionToValue(
   const exprNode = expr.node;
   const exprLoc = exprNode.loc ?? GeneratedSource;
   const loweredFunc = lowerFunction(builder, expr);
+  if (!loweredFunc) {
+    return {kind: 'UnsupportedNode', node: exprNode, loc: exprLoc};
+  }
   return {
     kind: 'FunctionExpression',
     name: loweredFunc.func.id,
@@ -3527,7 +3489,7 @@ function lowerFunction(
     | t.FunctionDeclaration
     | t.ObjectMethod
   >,
-): LoweredFunction {
+): LoweredFunction | null {
   const componentScope: Scope = builder.environment.parentFunction.scope;
   const capturedContext = gatherCapturedContext(expr, componentScope);
 
@@ -3539,12 +3501,19 @@ function lowerFunction(
    * This isn't a problem in practice because use Babel's scope analysis to
    * identify the correct references.
    */
-  const loweredFunc = lower(
+  const lowering = lower(
     expr,
     builder.environment,
     builder.bindings,
     new Map([...builder.context, ...capturedContext]),
   );
+  let loweredFunc: HIRFunction;
+  if (lowering.isErr()) {
+    const functionErrors = lowering.unwrapErr();
+    builder.errors.merge(functionErrors);
+    return null;
+  }
+  loweredFunc = lowering.unwrap();
   return {
     func: loweredFunc,
   };

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

@@ -773,6 +773,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);
   }

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

@@ -308,23 +308,33 @@ export default class HIRBuilder {
 
   resolveBinding(node: t.Identifier): Identifier {
     if (node.name === 'fbt') {
-      this.errors.push({
+      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',
-        loc: node.loc ?? GeneratedSource,
-        suggestions: null,
+        details: [
+          {
+            kind: 'error',
+            message: 'Rename to avoid conflict with fbt plugin',
+            loc: node.loc ?? GeneratedSource,
+          },
+        ],
       });
     }
     if (node.name === 'this') {
-      this.errors.push({
+      CompilerError.throwDiagnostic({
         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,
+        details: [
+          {
+            kind: 'error',
+            message: '`this` was used here',
+            loc: node.loc ?? GeneratedSource,
+          },
+        ],
       });
     }
     const originalName = node.name;
@@ -371,12 +381,11 @@ export default class HIRBuilder {
           instr => instr.value.kind === 'FunctionExpression',
         )
       ) {
-        this.errors.push({
+        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,
-          category: ErrorCategory.Todo,
         });
       }
     }

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

@@ -26,7 +26,7 @@ import {
   eachTerminalOperand,
 } from '../HIR/visitors';
 import {assertExhaustive, getOrInsertWith} from '../Utils/utils';
-
+import {Err, Ok, Result} from '../Utils/Result';
 import {AliasingEffect, MutationReason} from './AliasingEffects';
 
 /**
@@ -74,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> = [];
 
@@ -547,14 +547,10 @@ export function inferMutationAliasingRanges(
     }
   }
 
-  if (
-    errors.hasAnyErrors() &&
-    !isFunctionExpression &&
-    fn.env.enableValidations
-  ) {
-    fn.env.recordErrors(errors);
+  if (errors.hasAnyErrors() && !isFunctionExpression) {
+    return Err(errors);
   }
-  return functionEffects;
+  return Ok(functionEffects);
 }
 
 function appendFunctionErrors(errors: CompilerError, fn: HIRFunction): void {

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

@@ -46,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';
@@ -111,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 ]]',
@@ -141,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') {
@@ -269,7 +273,7 @@ export function codegenFunction(
         emitInstrumentForget.globalGating,
       );
       if (assertResult.isErr()) {
-        fn.env.recordErrors(assertResult.unwrapErr());
+        return assertResult;
       }
     }
 
@@ -319,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);
@@ -348,13 +355,13 @@ function codegenReactiveFunction(
   }
 
   if (cx.errors.hasAnyErrors()) {
-    fn.env.recordErrors(cx.errors);
+    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> {
@@ -775,13 +782,12 @@ function codegenTerminal(
         loc: terminal.init.loc,
       });
       if (terminal.init.instructions.length !== 2) {
-        cx.errors.push({
+        CompilerError.throwTodo({
           reason: 'Support non-trivial for..in inits',
-          category: ErrorCategory.Todo,
+          description: null,
           loc: terminal.init.loc,
           suggestions: null,
         });
-        return t.emptyStatement();
       }
       const iterableCollection = terminal.init.instructions[0];
       const iterableItem = terminal.init.instructions[1];
@@ -796,13 +802,12 @@ function codegenTerminal(
           break;
         }
         case 'StoreContext': {
-          cx.errors.push({
+          CompilerError.throwTodo({
             reason: 'Support non-trivial for..in inits',
-            category: ErrorCategory.Todo,
+            description: null,
             loc: terminal.init.loc,
             suggestions: null,
           });
-          return t.emptyStatement();
         }
         default:
           CompilerError.invariant(false, {
@@ -872,13 +877,12 @@ function codegenTerminal(
         loc: terminal.test.loc,
       });
       if (terminal.test.instructions.length !== 2) {
-        cx.errors.push({
+        CompilerError.throwTodo({
           reason: 'Support non-trivial for..of inits',
-          category: ErrorCategory.Todo,
+          description: null,
           loc: terminal.init.loc,
           suggestions: null,
         });
-        return t.emptyStatement();
       }
       const iterableItem = terminal.test.instructions[1];
       let lval: t.LVal;
@@ -892,13 +896,12 @@ function codegenTerminal(
           break;
         }
         case 'StoreContext': {
-          cx.errors.push({
+          CompilerError.throwTodo({
             reason: 'Support non-trivial for..of inits',
-            category: ErrorCategory.Todo,
+            description: null,
             loc: terminal.init.loc,
             suggestions: null,
           });
-          return t.emptyStatement();
         }
         default:
           CompilerError.invariant(false, {
@@ -1662,7 +1665,7 @@ function codegenInstructionValue(
                   cx.temp,
                 ),
                 reactiveFunction,
-              );
+              ).unwrap();
 
               /*
                * ObjectMethod builder must be backwards compatible with older versions of babel.
@@ -1861,7 +1864,7 @@ function codegenInstructionValue(
           cx.temp,
         ),
         reactiveFunction,
-      );
+      ).unwrap();
 
       if (instrValue.type === 'ArrowFunctionExpression') {
         let body: t.BlockStatement | t.Expression = fn.body;

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/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/ValidateNoDerivedComputationsInEffects.ts

@@ -97,7 +97,9 @@ export function validateNoDerivedComputationsInEffects(fn: HIRFunction): void {
       }
     }
   }
-  fn.env.recordErrors(errors);
+  if (errors.hasAnyErrors()) {
+    throw errors;
+  }
 }
 
 function validateEffect(

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

@@ -37,6 +37,7 @@ import {
   ReactiveFunctionVisitor,
   visitReactiveFunction,
 } from '../ReactiveScopes/visitors';
+import {Result} from '../Utils/Result';
 import {getOrInsertDefault} from '../Utils/utils';
 
 /**
@@ -46,13 +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 = {
     errors: new CompilerError(),
     manualMemoState: null,
   };
   visitReactiveFunction(fn, new Visitor(), state);
-  fn.env.recordErrors(state.errors);
+  return state.errors.asResult();
 }
 
 const DEBUG = false;

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

@@ -9,7 +9,7 @@ import {NodePath} from '@babel/traverse';
 import * as t from '@babel/types';
 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,7 @@ export function validateSourceLocations(
     t.FunctionDeclaration | t.ArrowFunctionExpression | t.FunctionExpression
   >,
   generatedAst: CodegenFunction,
-  env: Environment,
-): void {
+): Result<void, CompilerError> {
   const errors = new CompilerError();
 
   /*
@@ -310,5 +309,5 @@ export function validateSourceLocations(
     }
   }
 
-  env.recordErrors(errors);
+  return errors.asResult();
 }

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.dont-hoist-inline-reference.expect.md

@@ -21,15 +21,15 @@ export const FIXTURE_ENTRYPOINT = {
 ```
 Found 1 error:
 
-Todo: [hoisting] EnterSSA: Expected identifier to be defined before being used
+Invariant: [InferMutationAliasingEffects] Expected value kind to be initialized
 
-Identifier x$1 is undefined.
+<unknown> x$1.
 
-error.dont-hoist-inline-reference.ts:3:2
+error.dont-hoist-inline-reference.ts:3:21
   1 | import {identity} from 'shared-runtime';
   2 | function useInvalid() {
 > 3 |   const x = identity(x);
-    |   ^^^^^^^^^^^^^^^^^^^^^^ [hoisting] EnterSSA: Expected identifier to be defined before being used
+    |                      ^ this is uninitialized
   4 |   return x;
   5 | }
   6 |

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/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/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: {