[compiler] Phase 4 (batch 2), 5, 6: Update remaining passes for fault tolerance

Update remaining validation passes to record errors on env:
- validateMemoizedEffectDependencies
- validatePreservedManualMemoization
- validateSourceLocations (added env parameter)
- validateContextVariableLValues (changed throwTodo to recordError)
- validateLocalsNotReassignedAfterRender (changed throw to recordError)
- validateNoDerivedComputationsInEffects (changed throw to recordError)

Update inference passes:
- inferMutationAliasingEffects: return void, errors on env
- inferMutationAliasingRanges: return Array<AliasingEffect> directly, errors on env

Update codegen:
- codegenFunction: return CodegenFunction directly, errors on env
- codegenReactiveFunction: same pattern

Update Pipeline.ts to call all passes directly without tryRecord/unwrap.
Also update AnalyseFunctions.ts which called inferMutationAliasingRanges.

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
 
@@ -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,7 +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()`.
 

compiler/packages/babel-plugin-react-compiler/src/Babel/BabelPlugin.ts

@@ -11,7 +11,6 @@ import {
   injectReanimatedFlag,
   pipelineUsesReanimatedPlugin,
 } from '../Entrypoint/Reanimated';
-import validateNoUntransformedReferences from '../Entrypoint/ValidateNoUntransformedReferences';
 import {CompilerError} from '..';
 
 const ENABLE_REACT_COMPILER_TIMINGS =
@@ -64,19 +63,12 @@ export default function BabelPluginReactCompiler(
                 },
               };
             }
-            const result = compileProgram(prog, {
+            compileProgram(prog, {
               opts,
               filename: pass.filename ?? null,
               comments: pass.file.ast.comments ?? [],
               code: pass.file.code,
             });
-            validateNoUntransformedReferences(
-              prog,
-              pass.filename ?? null,
-              opts.logger,
-              opts.environment,
-              result,
-            );
             if (ENABLE_REACT_COMPILER_TIMINGS === true) {
               performance.mark(`${filename}:end`, {
                 detail: 'BabelPlugin:Program:end',

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

@@ -19,7 +19,7 @@ import {getOrInsertWith} from '../Utils/utils';
 import {ExternalFunction, isHookName} from '../HIR/Environment';
 import {Err, Ok, Result} from '../Utils/Result';
 import {LoggerEvent, ParsedPluginOptions} from './Options';
-import {BabelFn, getReactCompilerRuntimeModule} from './Program';
+import {getReactCompilerRuntimeModule} from './Program';
 import {SuppressionRange} from './Suppression';
 
 export function validateRestrictedImports(
@@ -84,11 +84,6 @@ export class ProgramContext {
   // generated imports
   imports: Map<string, Map<string, NonLocalImportSpecifier>> = new Map();
 
-  /**
-   * Metadata from compilation
-   */
-  retryErrors: Array<{fn: BabelFn; error: CompilerError}> = [];
-
   constructor({
     program,
     suppressions,

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

@@ -228,8 +228,6 @@ const CompilerOutputModeSchema = z.enum([
   'ssr',
   // Build optimized for the client, with auto memoization
   'client',
-  // Build optimized for the client without auto memo
-  'client-no-memo',
   // Lint mode, the output is unused but validations should run
   'lint',
 ]);

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

@@ -92,7 +92,6 @@ import {validateNoJSXInTryStatement} from '../Validation/ValidateNoJSXInTryState
 import {propagateScopeDependenciesHIR} from '../HIR/PropagateScopeDependenciesHIR';
 import {outlineJSX} from '../Optimization/OutlineJsx';
 import {optimizePropsMethodCalls} from '../Optimization/OptimizePropsMethodCalls';
-import {validateNoImpureFunctionsInRender} from '../Validation/ValidateNoImpureFunctionsInRender';
 import {validateStaticComponents} from '../Validation/ValidateStaticComponents';
 import {validateNoFreezingKnownMutableFunctions} from '../Validation/ValidateNoFreezingKnownMutableFunctions';
 import {inferMutationAliasingEffects} from '../Inference/InferMutationAliasingEffects';
@@ -156,12 +155,10 @@ 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});
 
-  env.tryRecord(() => {
-    pruneMaybeThrows(hir);
-  });
+  pruneMaybeThrows(hir);
   log({kind: 'hir', name: 'PruneMaybeThrows', value: hir});
 
   validateContextVariableLValues(hir);
@@ -172,43 +169,31 @@ function runWithEnvironment(
     log({kind: 'hir', name: 'DropManualMemoization', value: hir});
   }
 
-  env.tryRecord(() => {
-    inlineImmediatelyInvokedFunctionExpressions(hir);
-  });
+  inlineImmediatelyInvokedFunctionExpressions(hir);
   log({
     kind: 'hir',
     name: 'InlineImmediatelyInvokedFunctionExpressions',
     value: hir,
   });
 
-  env.tryRecord(() => {
-    mergeConsecutiveBlocks(hir);
-  });
+  mergeConsecutiveBlocks(hir);
   log({kind: 'hir', name: 'MergeConsecutiveBlocks', value: hir});
 
   assertConsistentIdentifiers(hir);
   assertTerminalSuccessorsExist(hir);
 
-  env.tryRecord(() => {
-    enterSSA(hir);
-  });
+  enterSSA(hir);
   log({kind: 'hir', name: 'SSA', value: hir});
 
-  env.tryRecord(() => {
-    eliminateRedundantPhi(hir);
-  });
+  eliminateRedundantPhi(hir);
   log({kind: 'hir', name: 'EliminateRedundantPhi', value: hir});
 
   assertConsistentIdentifiers(hir);
 
-  env.tryRecord(() => {
-    constantPropagation(hir);
-  });
+  constantPropagation(hir);
   log({kind: 'hir', name: 'ConstantPropagation', value: hir});
 
-  env.tryRecord(() => {
-    inferTypes(hir);
-  });
+  inferTypes(hir);
   log({kind: 'hir', name: 'InferTypes', value: hir});
 
   if (env.enableValidations) {
@@ -220,34 +205,24 @@ function runWithEnvironment(
     }
   }
 
-  env.tryRecord(() => {
-    optimizePropsMethodCalls(hir);
-  });
+  optimizePropsMethodCalls(hir);
   log({kind: 'hir', name: 'OptimizePropsMethodCalls', value: hir});
 
-  env.tryRecord(() => {
-    analyseFunctions(hir);
-  });
+  analyseFunctions(hir);
   log({kind: 'hir', name: 'AnalyseFunctions', value: hir});
 
   inferMutationAliasingEffects(hir);
   log({kind: 'hir', name: 'InferMutationAliasingEffects', value: hir});
 
   if (env.outputMode === 'ssr') {
-    env.tryRecord(() => {
-      optimizeForSSR(hir);
-    });
+    optimizeForSSR(hir);
     log({kind: 'hir', name: 'OptimizeForSSR', value: hir});
   }
 
   // Note: Has to come after infer reference effects because "dead" code may still affect inference
-  env.tryRecord(() => {
-    deadCodeElimination(hir);
-  });
+  deadCodeElimination(hir);
   log({kind: 'hir', name: 'DeadCodeElimination', value: hir});
-  env.tryRecord(() => {
-    pruneMaybeThrows(hir);
-  });
+  pruneMaybeThrows(hir);
   log({kind: 'hir', name: 'PruneMaybeThrows', value: hir});
 
   inferMutationAliasingRanges(hir, {
@@ -288,16 +263,12 @@ function runWithEnvironment(
       env.logErrors(validateNoJSXInTryStatement(hir));
     }
 
-    if (env.config.validateNoImpureFunctionsInRender) {
-      validateNoImpureFunctionsInRender(hir);
-    }
-
-    validateNoFreezingKnownMutableFunctions(hir);
+    env.tryRecord(() => {
+      validateNoFreezingKnownMutableFunctions(hir);
+    });
   }
 
-  env.tryRecord(() => {
-    inferReactivePlaces(hir);
-  });
+  inferReactivePlaces(hir);
   log({kind: 'hir', name: 'InferReactivePlaces', value: hir});
 
   if (env.enableValidations) {
@@ -310,9 +281,7 @@ function runWithEnvironment(
     }
   }
 
-  env.tryRecord(() => {
-    rewriteInstructionKindsBasedOnReassignment(hir);
-  });
+  rewriteInstructionKindsBasedOnReassignment(hir);
   log({
     kind: 'hir',
     name: 'RewriteInstructionKindsBasedOnReassignment',
@@ -333,16 +302,12 @@ function runWithEnvironment(
      * if inferred memoization is enabled. This makes all later passes which
      * transform reactive-scope labeled instructions no-ops.
      */
-    env.tryRecord(() => {
-      inferReactiveScopeVariables(hir);
-    });
+    inferReactiveScopeVariables(hir);
     log({kind: 'hir', name: 'InferReactiveScopeVariables', value: hir});
   }
 
   let fbtOperands: Set<IdentifierId> = new Set();
-  env.tryRecord(() => {
-    fbtOperands = memoizeFbtAndMacroOperandsInSameScope(hir);
-  });
+  fbtOperands = memoizeFbtAndMacroOperandsInSameScope(hir);
   log({
     kind: 'hir',
     name: 'MemoizeFbtAndMacroOperandsInSameScope',
@@ -350,15 +315,11 @@ function runWithEnvironment(
   });
 
   if (env.config.enableJsxOutlining) {
-    env.tryRecord(() => {
-      outlineJSX(hir);
-    });
+    outlineJSX(hir);
   }
 
   if (env.config.enableNameAnonymousFunctions) {
-    env.tryRecord(() => {
-      nameAnonymousFunctions(hir);
-    });
+    nameAnonymousFunctions(hir);
     log({
       kind: 'hir',
       name: 'NameAnonymousFunctions',
@@ -367,51 +328,39 @@ function runWithEnvironment(
   }
 
   if (env.config.enableFunctionOutlining) {
-    env.tryRecord(() => {
-      outlineFunctions(hir, fbtOperands);
-    });
+    outlineFunctions(hir, fbtOperands);
     log({kind: 'hir', name: 'OutlineFunctions', value: hir});
   }
 
-  env.tryRecord(() => {
-    alignMethodCallScopes(hir);
-  });
+  alignMethodCallScopes(hir);
   log({
     kind: 'hir',
     name: 'AlignMethodCallScopes',
     value: hir,
   });
 
-  env.tryRecord(() => {
-    alignObjectMethodScopes(hir);
-  });
+  alignObjectMethodScopes(hir);
   log({
     kind: 'hir',
     name: 'AlignObjectMethodScopes',
     value: hir,
   });
 
-  env.tryRecord(() => {
-    pruneUnusedLabelsHIR(hir);
-  });
+  pruneUnusedLabelsHIR(hir);
   log({
     kind: 'hir',
     name: 'PruneUnusedLabelsHIR',
     value: hir,
   });
 
-  env.tryRecord(() => {
-    alignReactiveScopesToBlockScopesHIR(hir);
-  });
+  alignReactiveScopesToBlockScopesHIR(hir);
   log({
     kind: 'hir',
     name: 'AlignReactiveScopesToBlockScopesHIR',
     value: hir,
   });
 
-  env.tryRecord(() => {
-    mergeOverlappingReactiveScopesHIR(hir);
-  });
+  mergeOverlappingReactiveScopesHIR(hir);
   log({
     kind: 'hir',
     name: 'MergeOverlappingReactiveScopesHIR',
@@ -419,9 +368,7 @@ function runWithEnvironment(
   });
   assertValidBlockNesting(hir);
 
-  env.tryRecord(() => {
-    buildReactiveScopeTerminalsHIR(hir);
-  });
+  buildReactiveScopeTerminalsHIR(hir);
   log({
     kind: 'hir',
     name: 'BuildReactiveScopeTerminalsHIR',
@@ -430,18 +377,14 @@ function runWithEnvironment(
 
   assertValidBlockNesting(hir);
 
-  env.tryRecord(() => {
-    flattenReactiveLoopsHIR(hir);
-  });
+  flattenReactiveLoopsHIR(hir);
   log({
     kind: 'hir',
     name: 'FlattenReactiveLoopsHIR',
     value: hir,
   });
 
-  env.tryRecord(() => {
-    flattenScopesWithHooksOrUseHIR(hir);
-  });
+  flattenScopesWithHooksOrUseHIR(hir);
   log({
     kind: 'hir',
     name: 'FlattenScopesWithHooksOrUseHIR',
@@ -449,9 +392,7 @@ function runWithEnvironment(
   });
   assertTerminalSuccessorsExist(hir);
   assertTerminalPredsExist(hir);
-  env.tryRecord(() => {
-    propagateScopeDependenciesHIR(hir);
-  });
+  propagateScopeDependenciesHIR(hir);
   log({
     kind: 'hir',
     name: 'PropagateScopeDependenciesHIR',
@@ -459,9 +400,7 @@ function runWithEnvironment(
   });
 
   let reactiveFunction!: ReactiveFunction;
-  env.tryRecord(() => {
-    reactiveFunction = buildReactiveFunction(hir);
-  });
+  reactiveFunction = buildReactiveFunction(hir);
   log({
     kind: 'reactive',
     name: 'BuildReactiveFunction',
@@ -470,9 +409,7 @@ function runWithEnvironment(
 
   assertWellFormedBreakTargets(reactiveFunction);
 
-  env.tryRecord(() => {
-    pruneUnusedLabels(reactiveFunction);
-  });
+  pruneUnusedLabels(reactiveFunction);
   log({
     kind: 'reactive',
     name: 'PruneUnusedLabels',
@@ -480,90 +417,70 @@ function runWithEnvironment(
   });
   assertScopeInstructionsWithinScopes(reactiveFunction);
 
-  env.tryRecord(() => {
-    pruneNonEscapingScopes(reactiveFunction);
-  });
+  pruneNonEscapingScopes(reactiveFunction);
   log({
     kind: 'reactive',
     name: 'PruneNonEscapingScopes',
     value: reactiveFunction,
   });
 
-  env.tryRecord(() => {
-    pruneNonReactiveDependencies(reactiveFunction);
-  });
+  pruneNonReactiveDependencies(reactiveFunction);
   log({
     kind: 'reactive',
     name: 'PruneNonReactiveDependencies',
     value: reactiveFunction,
   });
 
-  env.tryRecord(() => {
-    pruneUnusedScopes(reactiveFunction);
-  });
+  pruneUnusedScopes(reactiveFunction);
   log({
     kind: 'reactive',
     name: 'PruneUnusedScopes',
     value: reactiveFunction,
   });
 
-  env.tryRecord(() => {
-    mergeReactiveScopesThatInvalidateTogether(reactiveFunction);
-  });
+  mergeReactiveScopesThatInvalidateTogether(reactiveFunction);
   log({
     kind: 'reactive',
     name: 'MergeReactiveScopesThatInvalidateTogether',
     value: reactiveFunction,
   });
 
-  env.tryRecord(() => {
-    pruneAlwaysInvalidatingScopes(reactiveFunction);
-  });
+  pruneAlwaysInvalidatingScopes(reactiveFunction);
   log({
     kind: 'reactive',
     name: 'PruneAlwaysInvalidatingScopes',
     value: reactiveFunction,
   });
 
-  env.tryRecord(() => {
-    propagateEarlyReturns(reactiveFunction);
-  });
+  propagateEarlyReturns(reactiveFunction);
   log({
     kind: 'reactive',
     name: 'PropagateEarlyReturns',
     value: reactiveFunction,
   });
 
-  env.tryRecord(() => {
-    pruneUnusedLValues(reactiveFunction);
-  });
+  pruneUnusedLValues(reactiveFunction);
   log({
     kind: 'reactive',
     name: 'PruneUnusedLValues',
     value: reactiveFunction,
   });
 
-  env.tryRecord(() => {
-    promoteUsedTemporaries(reactiveFunction);
-  });
+  promoteUsedTemporaries(reactiveFunction);
   log({
     kind: 'reactive',
     name: 'PromoteUsedTemporaries',
     value: reactiveFunction,
   });
 
-  env.tryRecord(() => {
-    extractScopeDeclarationsFromDestructuring(reactiveFunction);
-  });
+  extractScopeDeclarationsFromDestructuring(reactiveFunction);
   log({
     kind: 'reactive',
     name: 'ExtractScopeDeclarationsFromDestructuring',
     value: reactiveFunction,
   });
 
-  env.tryRecord(() => {
-    stabilizeBlockIds(reactiveFunction);
-  });
+  stabilizeBlockIds(reactiveFunction);
   log({
     kind: 'reactive',
     name: 'StabilizeBlockIds',
@@ -571,25 +488,20 @@ function runWithEnvironment(
   });
 
   let uniqueIdentifiers: Set<string> = new Set();
-  env.tryRecord(() => {
-    uniqueIdentifiers = renameVariables(reactiveFunction);
-  });
+  uniqueIdentifiers = renameVariables(reactiveFunction);
   log({
     kind: 'reactive',
     name: 'RenameVariables',
     value: reactiveFunction,
   });
 
-  env.tryRecord(() => {
-    pruneHoistedContexts(reactiveFunction);
-  });
+  pruneHoistedContexts(reactiveFunction);
   log({
     kind: 'reactive',
     name: 'PruneHoistedContexts',
     value: reactiveFunction,
   });
 
-
   if (
     env.config.enablePreserveExistingMemoizationGuarantees ||
     env.config.validatePreserveExistingMemoizationGuarantees

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

@@ -350,9 +350,6 @@ function isFilePartOfSources(
   return false;
 }
 
-export type CompileProgramMetadata = {
-  retryErrors: Array<{fn: BabelFn; error: CompilerError}>;
-};
 /**
  * Main entrypoint for React Compiler.
  *
@@ -363,7 +360,7 @@ export type CompileProgramMetadata = {
 export function compileProgram(
   program: NodePath<t.Program>,
   pass: CompilerPass,
-): CompileProgramMetadata | null {
+): void {
   /**
    * This is directly invoked by the react-compiler babel plugin, so exceptions
    * thrown by this function will fail the babel build.
@@ -376,7 +373,7 @@ export function compileProgram(
    *   the outlined functions.
    */
   if (shouldSkipCompilation(program, pass)) {
-    return null;
+    return;
   }
   const restrictedImportsErr = validateRestrictedImports(
     program,
@@ -384,7 +381,7 @@ export function compileProgram(
   );
   if (restrictedImportsErr) {
     handleError(restrictedImportsErr, pass, null);
-    return null;
+    return;
   }
   /*
    * Record lint errors and critical errors as depending on Forget's config,
@@ -478,15 +475,11 @@ export function compileProgram(
       );
       handleError(error, programContext, null);
     }
-    return null;
+    return;
   }
 
   // Insert React Compiler generated functions into the Babel AST
   applyCompiledFunctions(program, compiledFns, pass, programContext);
-
-  return {
-    retryErrors: programContext.retryErrors,
-  };
 }
 
 type CompileSource = {
@@ -724,7 +717,6 @@ function tryCompileFunction(
   }
 }
 
-
 /**
  * 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/Entrypoint/ValidateNoUntransformedReferences.ts

@@ -1,162 +0,0 @@
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-import {NodePath} from '@babel/core';
-import * as t from '@babel/types';
-
-import {CompilerError, EnvironmentConfig, Logger} from '..';
-import {getOrInsertWith} from '../Utils/utils';
-import {GeneratedSource} from '../HIR';
-import {DEFAULT_EXPORT} from '../HIR/Environment';
-import {CompileProgramMetadata} from './Program';
-export default function validateNoUntransformedReferences(
-  path: NodePath<t.Program>,
-  filename: string | null,
-  logger: Logger | null,
-  env: EnvironmentConfig,
-  compileResult: CompileProgramMetadata | null,
-): void {
-  const moduleLoadChecks = new Map<
-    string,
-    Map<string, CheckInvalidReferenceFn>
-  >();
-  if (moduleLoadChecks.size > 0) {
-    transformProgram(path, moduleLoadChecks, filename, logger, compileResult);
-  }
-}
-
-type TraversalState = {
-  shouldInvalidateScopes: boolean;
-  program: NodePath<t.Program>;
-  logger: Logger | null;
-  filename: string | null;
-  transformErrors: Array<{fn: NodePath<t.Node>; error: CompilerError}>;
-};
-type CheckInvalidReferenceFn = (
-  paths: Array<NodePath<t.Node>>,
-  context: TraversalState,
-) => void;
-
-function validateImportSpecifier(
-  specifier: NodePath<t.ImportSpecifier>,
-  importSpecifierChecks: Map<string, CheckInvalidReferenceFn>,
-  state: TraversalState,
-): void {
-  const imported = specifier.get('imported');
-  const specifierName: string =
-    imported.node.type === 'Identifier'
-      ? imported.node.name
-      : imported.node.value;
-  const checkFn = importSpecifierChecks.get(specifierName);
-  if (checkFn == null) {
-    return;
-  }
-  if (state.shouldInvalidateScopes) {
-    state.shouldInvalidateScopes = false;
-    state.program.scope.crawl();
-  }
-
-  const local = specifier.get('local');
-  const binding = local.scope.getBinding(local.node.name);
-  CompilerError.invariant(binding != null, {
-    reason: 'Expected binding to be found for import specifier',
-    loc: local.node.loc ?? GeneratedSource,
-  });
-  checkFn(binding.referencePaths, state);
-}
-
-function validateNamespacedImport(
-  specifier: NodePath<t.ImportNamespaceSpecifier | t.ImportDefaultSpecifier>,
-  importSpecifierChecks: Map<string, CheckInvalidReferenceFn>,
-  state: TraversalState,
-): void {
-  if (state.shouldInvalidateScopes) {
-    state.shouldInvalidateScopes = false;
-    state.program.scope.crawl();
-  }
-  const local = specifier.get('local');
-  const binding = local.scope.getBinding(local.node.name);
-  const defaultCheckFn = importSpecifierChecks.get(DEFAULT_EXPORT);
-
-  CompilerError.invariant(binding != null, {
-    reason: 'Expected binding to be found for import specifier',
-    loc: local.node.loc ?? GeneratedSource,
-  });
-  const filteredReferences = new Map<
-    CheckInvalidReferenceFn,
-    Array<NodePath<t.Node>>
-  >();
-  for (const reference of binding.referencePaths) {
-    if (defaultCheckFn != null) {
-      getOrInsertWith(filteredReferences, defaultCheckFn, () => []).push(
-        reference,
-      );
-    }
-    const parent = reference.parentPath;
-    if (
-      parent != null &&
-      parent.isMemberExpression() &&
-      parent.get('object') === reference
-    ) {
-      if (parent.node.computed || parent.node.property.type !== 'Identifier') {
-        continue;
-      }
-      const checkFn = importSpecifierChecks.get(parent.node.property.name);
-      if (checkFn != null) {
-        getOrInsertWith(filteredReferences, checkFn, () => []).push(parent);
-      }
-    }
-  }
-
-  for (const [checkFn, references] of filteredReferences) {
-    checkFn(references, state);
-  }
-}
-function transformProgram(
-  path: NodePath<t.Program>,
-
-  moduleLoadChecks: Map<string, Map<string, CheckInvalidReferenceFn>>,
-  filename: string | null,
-  logger: Logger | null,
-  compileResult: CompileProgramMetadata | null,
-): void {
-  const traversalState: TraversalState = {
-    shouldInvalidateScopes: true,
-    program: path,
-    filename,
-    logger,
-    transformErrors: compileResult?.retryErrors ?? [],
-  };
-  path.traverse({
-    ImportDeclaration(path: NodePath<t.ImportDeclaration>) {
-      const importSpecifierChecks = moduleLoadChecks.get(
-        path.node.source.value,
-      );
-      if (importSpecifierChecks == null) {
-        return;
-      }
-      const specifiers = path.get('specifiers');
-      for (const specifier of specifiers) {
-        if (specifier.isImportSpecifier()) {
-          validateImportSpecifier(
-            specifier,
-            importSpecifierChecks,
-            traversalState,
-          );
-        } else {
-          validateNamespacedImport(
-            specifier as NodePath<
-              t.ImportNamespaceSpecifier | t.ImportDefaultSpecifier
-            >,
-            importSpecifierChecks,
-            traversalState,
-          );
-        }
-      }
-    },
-  });
-}

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,
@@ -185,51 +186,32 @@ export function lower(
 
   let directives: Array<string> = [];
   const body = func.get('body');
-  try {
-    if (body.isExpression()) {
-      const fallthrough = builder.reserve('block');
-      const terminal: ReturnTerminal = {
-        kind: 'return',
-        returnVariant: 'Implicit',
-        loc: GeneratedSource,
-        value: lowerExpressionToTemporary(builder, body),
-        id: makeInstructionId(0),
-        effects: null,
-      };
-      builder.terminateWithContinuation(terminal, fallthrough);
-    } else if (body.isBlockStatement()) {
-      lowerStatement(builder, body);
-      directives = body.get('directives').map(d => d.node.value.value);
-    } else {
-      builder.errors.pushDiagnostic(
-        CompilerDiagnostic.create({
-          category: ErrorCategory.Syntax,
-          reason: `Unexpected function body kind`,
-          description: `Expected function body to be an expression or a block statement, got \`${body.type}\``,
-        }).withDetails({
-          kind: 'error',
-          loc: body.node.loc ?? null,
-          message: 'Expected a block statement or expression',
-        }),
-      );
-    }
-  } catch (err) {
-    if (err instanceof CompilerError) {
-      // Re-throw invariant errors immediately
-      for (const detail of err.details) {
-        if (
-          (detail instanceof CompilerDiagnostic
-            ? detail.category
-            : detail.category) === ErrorCategory.Invariant
-        ) {
-          throw err;
-        }
-      }
-      // Record non-invariant errors and continue to produce partial HIR
-      builder.errors.merge(err);
-    } else {
-      throw err;
-    }
+  if (body.isExpression()) {
+    const fallthrough = builder.reserve('block');
+    const terminal: ReturnTerminal = {
+      kind: 'return',
+      returnVariant: 'Implicit',
+      loc: GeneratedSource,
+      value: lowerExpressionToTemporary(builder, body),
+      id: makeInstructionId(0),
+      effects: null,
+    };
+    builder.terminateWithContinuation(terminal, fallthrough);
+  } else if (body.isBlockStatement()) {
+    lowerStatement(builder, body);
+    directives = body.get('directives').map(d => d.node.value.value);
+  } else {
+    builder.errors.pushDiagnostic(
+      CompilerDiagnostic.create({
+        category: ErrorCategory.Syntax,
+        reason: `Unexpected function body kind`,
+        description: `Expected function body to be an expression or a block statement, got \`${body.type}\``,
+      }).withDetails({
+        kind: 'error',
+        loc: body.node.loc ?? null,
+        message: 'Expected a block statement or expression',
+      }),
+    );
   }
 
   let validatedId: HIRFunction['id'] = null;
@@ -242,6 +224,10 @@ export function lower(
     }
   }
 
+  if (builder.errors.hasAnyErrors()) {
+    return Err(builder.errors);
+  }
+
   builder.terminate(
     {
       kind: 'return',
@@ -258,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
@@ -575,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:
@@ -599,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,
           };
@@ -677,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(
           {
@@ -917,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');
@@ -1555,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',
@@ -2334,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,
+                };
               }),
-            );
+            });
           }
         }
       }
@@ -3528,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,
@@ -3546,7 +3489,7 @@ function lowerFunction(
     | t.FunctionDeclaration
     | t.ObjectMethod
   >,
-): LoweredFunction {
+): LoweredFunction | null {
   const componentScope: Scope = builder.environment.parentFunction.scope;
   const capturedContext = gatherCapturedContext(expr, componentScope);
 
@@ -3558,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/Environment.ts

@@ -640,9 +640,6 @@ export class Environment {
       case 'ssr': {
         return true;
       }
-      case 'client-no-memo': {
-        return false;
-      }
       default: {
         assertExhaustive(
           this.outputMode,
@@ -659,8 +656,7 @@ export class Environment {
         // linting also enables memoization so that we can check if manual memoization is preserved
         return true;
       }
-      case 'ssr':
-      case 'client-no-memo': {
+      case 'ssr': {
         return false;
       }
       default: {
@@ -679,9 +675,6 @@ export class Environment {
       case 'ssr': {
         return true;
       }
-      case 'client-no-memo': {
-        return false;
-      }
       default: {
         assertExhaustive(
           this.outputMode,
@@ -741,13 +734,6 @@ export class Environment {
     } else {
       this.#errors.pushErrorDetail(error);
     }
-    if (this.logger != null) {
-      this.logger.logEvent(this.filename, {
-        kind: 'CompileError',
-        detail: error,
-        fnLoc: null,
-      });
-    }
   }
 
   /**

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

@@ -381,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/__tests__/fixtures/compiler/ecma/error.reserved-words.expect.md

@@ -24,9 +24,18 @@ function useThing(fn) {
 ```
 Found 1 error:
 
-Invariant: [HIRBuilder] Unexpected null block
+Compilation Skipped: `this` is not supported syntax
 
-expected block 0 to exist.
+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:
 
-Invariant: [InferMutationAliasingEffects] Expected value kind to be initialized
+Todo: [hoisting] EnterSSA: Expected identifier to be defined before being used
 
-<unknown> x$1.
+Identifier x$1 is undefined.
 
-error.dont-hoist-inline-reference.ts:3:21
+error.dont-hoist-inline-reference.ts:3:2
   1 | import {identity} from 'shared-runtime';
   2 | function useInvalid() {
 > 3 |   const x = identity(x);
-    |                      ^ this is uninitialized
+    |   ^^^^^^^^^^^^^^^^^^^^^^ [hoisting] EnterSSA: Expected identifier to be defined before being used
   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.invalid-impure-functions-in-render.expect.md

@@ -17,7 +17,7 @@ function Component() {
 ## Error
 
 ```
-Found 6 errors:
+Found 3 errors:
 
 Error: Cannot call impure function during render
 
@@ -57,45 +57,6 @@ error.invalid-impure-functions-in-render.ts:6:15
   7 |   return <Foo date={date} now={now} rand={rand} />;
   8 | }
   9 |
-
-Error: Cannot call impure function during render
-
-`Date.now` is an impure function. Calling an impure function can produce unstable results that update unpredictably when the component happens to re-render. (https://react.dev/reference/rules/components-and-hooks-must-be-pure#components-and-hooks-must-be-idempotent).
-
-error.invalid-impure-functions-in-render.ts:4:15
-  2 |
-  3 | function Component() {
-> 4 |   const date = Date.now();
-    |                ^^^^^^^^ Cannot call impure function
-  5 |   const now = performance.now();
-  6 |   const rand = Math.random();
-  7 |   return <Foo date={date} now={now} rand={rand} />;
-
-Error: Cannot call impure function during render
-
-`performance.now` is an impure function. Calling an impure function can produce unstable results that update unpredictably when the component happens to re-render. (https://react.dev/reference/rules/components-and-hooks-must-be-pure#components-and-hooks-must-be-idempotent).
-
-error.invalid-impure-functions-in-render.ts:5:14
-  3 | function Component() {
-  4 |   const date = Date.now();
-> 5 |   const now = performance.now();
-    |               ^^^^^^^^^^^^^^^ Cannot call impure function
-  6 |   const rand = Math.random();
-  7 |   return <Foo date={date} now={now} rand={rand} />;
-  8 | }
-
-Error: Cannot call impure function during render
-
-`Math.random` is an impure function. Calling an impure function can produce unstable results that update unpredictably when the component happens to re-render. (https://react.dev/reference/rules/components-and-hooks-must-be-pure#components-and-hooks-must-be-idempotent).
-
-error.invalid-impure-functions-in-render.ts:6:15
-  4 |   const date = Date.now();
-  5 |   const now = performance.now();
-> 6 |   const rand = Math.random();
-    |                ^^^^^^^^^^^ Cannot call impure function
-  7 |   return <Foo date={date} now={now} rand={rand} />;
-  8 | }
-  9 |
 ```
           
       

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.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/gating/dynamic-gating-bailout-nopanic.expect.md

@@ -58,7 +58,6 @@ export const FIXTURE_ENTRYPOINT = {
 ## Logs
 
 ```
-{"kind":"CompileError","detail":{"options":{"category":"PreserveManualMemo","reason":"Existing memoization could not be preserved","description":"React Compiler has skipped optimizing this component because the existing manual memoization could not be preserved. The inferred dependencies did not match the manually specified dependencies, which could cause the value to change more or less frequently than expected. The inferred dependency was `value`, but the source dependencies were []. Inferred dependency not present in source","suggestions":null,"details":[{"kind":"error","loc":{"start":{"line":9,"column":31,"index":337},"end":{"line":9,"column":52,"index":358},"filename":"dynamic-gating-bailout-nopanic.ts"},"message":"Could not preserve existing manual memoization"}]}},"fnLoc":null}
 {"kind":"CompileError","fnLoc":{"start":{"line":6,"column":0,"index":255},"end":{"line":16,"column":1,"index":482},"filename":"dynamic-gating-bailout-nopanic.ts"},"detail":{"options":{"category":"PreserveManualMemo","reason":"Existing memoization could not be preserved","description":"React Compiler has skipped optimizing this component because the existing manual memoization could not be preserved. The inferred dependencies did not match the manually specified dependencies, which could cause the value to change more or less frequently than expected. The inferred dependency was `value`, but the source dependencies were []. Inferred dependency not present in source","suggestions":null,"details":[{"kind":"error","loc":{"start":{"line":9,"column":31,"index":337},"end":{"line":9,"column":52,"index":358},"filename":"dynamic-gating-bailout-nopanic.ts"},"message":"Could not preserve existing manual memoization"}]}}}
 ```
       

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/new-mutability/error.invalid-impure-functions-in-render.expect.md

@@ -17,7 +17,7 @@ function Component() {
 ## Error
 
 ```
-Found 6 errors:
+Found 3 errors:
 
 Error: Cannot call impure function during render
 
@@ -57,45 +57,6 @@ error.invalid-impure-functions-in-render.ts:6:15
   7 |   return <Foo date={date} now={now} rand={rand} />;
   8 | }
   9 |
-
-Error: Cannot call impure function during render
-
-`Date.now` is an impure function. Calling an impure function can produce unstable results that update unpredictably when the component happens to re-render. (https://react.dev/reference/rules/components-and-hooks-must-be-pure#components-and-hooks-must-be-idempotent).
-
-error.invalid-impure-functions-in-render.ts:4:15
-  2 |
-  3 | function Component() {
-> 4 |   const date = Date.now();
-    |                ^^^^^^^^ Cannot call impure function
-  5 |   const now = performance.now();
-  6 |   const rand = Math.random();
-  7 |   return <Foo date={date} now={now} rand={rand} />;
-
-Error: Cannot call impure function during render
-
-`performance.now` is an impure function. Calling an impure function can produce unstable results that update unpredictably when the component happens to re-render. (https://react.dev/reference/rules/components-and-hooks-must-be-pure#components-and-hooks-must-be-idempotent).
-
-error.invalid-impure-functions-in-render.ts:5:14
-  3 | function Component() {
-  4 |   const date = Date.now();
-> 5 |   const now = performance.now();
-    |               ^^^^^^^^^^^^^^^ Cannot call impure function
-  6 |   const rand = Math.random();
-  7 |   return <Foo date={date} now={now} rand={rand} />;
-  8 | }
-
-Error: Cannot call impure function during render
-
-`Math.random` is an impure function. Calling an impure function can produce unstable results that update unpredictably when the component happens to re-render. (https://react.dev/reference/rules/components-and-hooks-must-be-pure#components-and-hooks-must-be-idempotent).
-
-error.invalid-impure-functions-in-render.ts:6:15
-  4 |   const date = Date.now();
-  5 |   const now = performance.now();
-> 6 |   const rand = Math.random();
-    |                ^^^^^^^^^^^ Cannot call impure function
-  7 |   return <Foo date={date} now={now} rand={rand} />;
-  8 | }
-  9 |
 ```
           
       

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/eslint-plugin-react-compiler/__tests__/NoCapitalizedCallsRule-test.ts

@@ -64,6 +64,9 @@ testRule(
           makeTestCaseError(
             'Capitalized functions are reserved for components',
           ),
+          makeTestCaseError(
+            'Capitalized functions are reserved for components',
+          ),
         ],
       },
     ],

compiler/packages/eslint-plugin-react-compiler/__tests__/PluginTest-test.ts

@@ -57,7 +57,6 @@ testRule('plugin-recommended', TestRecommendedRules, {
   ],
   invalid: [
     {
-      // TODO: actually return multiple diagnostics in this case
       name: 'Multiple diagnostic kinds from the same function are surfaced',
       code: normalizeIndent`
         import Child from './Child';
@@ -70,6 +69,7 @@ testRule('plugin-recommended', TestRecommendedRules, {
       `,
       errors: [
         makeTestCaseError('Hooks must always be called in a consistent order'),
+        makeTestCaseError('Capitalized functions are reserved for components'),
       ],
     },
     {
@@ -128,6 +128,7 @@ testRule('plugin-recommended', TestRecommendedRules, {
         makeTestCaseError(
           'Calling setState from useMemo may trigger an infinite loop',
         ),
+        makeTestCaseError('Found extra memoization dependencies'),
       ],
     },
   ],

packages/react-reconciler/src/ReactFiberBeginWork.js

@@ -3991,9 +3991,23 @@ function attemptEarlyBailoutIfNoScheduledUpdate(
         // whether to retry the primary children, or to skip over it and
         // go straight to the fallback. Check the priority of the primary
         // child fragment.
+        //
+        // Propagate context changes first. If a parent context changed
+        // and the primary children's consumer fibers were discarded
+        // during initial mount suspension, normal propagation can't find
+        // them. In that case we conservatively retry the boundary — the
+        // re-mounted children will read the updated context value.
+        const contextChanged = lazilyPropagateParentContextChanges(
+          current,
+          workInProgress,
+          renderLanes,
+        );
         const primaryChildFragment: Fiber = (workInProgress.child: any);
         const primaryChildLanes = primaryChildFragment.childLanes;
-        if (includesSomeLane(renderLanes, primaryChildLanes)) {
+        if (
+          contextChanged ||
+          includesSomeLane(renderLanes, primaryChildLanes)
+        ) {
           // The primary children have pending work. Use the normal path
           // to attempt to render the primary children again.
           return updateSuspenseComponent(current, workInProgress, renderLanes);

packages/react-reconciler/src/ReactFiberNewContext.js

@@ -20,7 +20,11 @@ import type {Hook} from './ReactFiberHooks';
 
 import {isPrimaryRenderer, HostTransitionContext} from './ReactFiberConfig';
 import {createCursor, push, pop} from './ReactFiberStack';
-import {ContextProvider, DehydratedFragment} from './ReactWorkTags';
+import {
+  ContextProvider,
+  DehydratedFragment,
+  SuspenseComponent,
+} from './ReactWorkTags';
 import {NoLanes, isSubsetOfLanes, mergeLanes} from './ReactFiberLane';
 import {
   NoFlags,
@@ -295,6 +299,37 @@ function propagateContextChanges<T>(
         workInProgress,
       );
       nextFiber = null;
+    } else if (
+      fiber.tag === SuspenseComponent &&
+      fiber.memoizedState !== null &&
+      fiber.memoizedState.dehydrated === null
+    ) {
+      // This is a client-rendered Suspense boundary that is currently
+      // showing its fallback. The primary children may include context
+      // consumers, but their fibers may not exist in the tree — during
+      // initial mount, if the primary children suspended, their fibers
+      // were discarded since there was no current tree to preserve them.
+      // We can't walk into the primary tree to find consumers, so
+      // conservatively mark the Suspense boundary itself for retry.
+      // When it re-renders, it will re-mount the primary children,
+      // which will read the updated context value.
+      fiber.lanes = mergeLanes(fiber.lanes, renderLanes);
+      const alternate = fiber.alternate;
+      if (alternate !== null) {
+        alternate.lanes = mergeLanes(alternate.lanes, renderLanes);
+      }
+      scheduleContextWorkOnParentPath(
+        fiber.return,
+        renderLanes,
+        workInProgress,
+      );
+      if (!forcePropagateEntireTree) {
+        // During lazy propagation, we can defer propagating changes to
+        // the children, same as the consumer match above.
+        nextFiber = null;
+      } else {
+        nextFiber = fiber.child;
+      }
     } else {
       // Traverse down.
       nextFiber = fiber.child;
@@ -331,9 +366,9 @@ export function lazilyPropagateParentContextChanges(
   current: Fiber,
   workInProgress: Fiber,
   renderLanes: Lanes,
-) {
+): boolean {
   const forcePropagateEntireTree = false;
-  propagateParentContextChanges(
+  return propagateParentContextChanges(
     current,
     workInProgress,
     renderLanes,
@@ -364,7 +399,7 @@ function propagateParentContextChanges(
   workInProgress: Fiber,
   renderLanes: Lanes,
   forcePropagateEntireTree: boolean,
-) {
+): boolean {
   // Collect all the parent providers that changed. Since this is usually small
   // number, we use an Array instead of Set.
   let contexts = null;
@@ -460,6 +495,7 @@ function propagateParentContextChanges(
   // then we could remove both `DidPropagateContext` and `NeedsPropagation`.
   // Consider this as part of the next refactor to the fiber tree structure.
   workInProgress.flags |= DidPropagateContext;
+  return contexts !== null;
 }
 
 export function checkIfContextChanged(

packages/react-reconciler/src/__tests__/ReactContextPropagation-test.js

@@ -2,6 +2,7 @@ let React;
 let ReactNoop;
 let Scheduler;
 let act;
+let use;
 let useState;
 let useContext;
 let Suspense;
@@ -19,6 +20,7 @@ describe('ReactLazyContextPropagation', () => {
     ReactNoop = require('react-noop-renderer');
     Scheduler = require('scheduler');
     act = require('internal-test-utils').act;
+    use = React.use;
     useState = React.useState;
     useContext = React.useContext;
     Suspense = React.Suspense;
@@ -937,4 +939,102 @@ describe('ReactLazyContextPropagation', () => {
     assertLog(['B', 'B']);
     expect(root).toMatchRenderedOutput('BB');
   });
+
+  it('regression: context change triggers retry of suspended Suspense boundary on initial mount', async () => {
+    // Regression test for a bug where a context change above a suspended
+    // Suspense boundary would fail to trigger a retry. When a Suspense
+    // boundary suspends during initial mount, the primary children's fibers
+    // are discarded because there is no current tree to preserve them. If
+    // the suspended promise never resolves, the only way to retry is
+    // something external — like a context change. Context propagation must
+    // mark suspended Suspense boundaries for retry even though the consumer
+    // fibers no longer exist in the tree.
+    //
+    // The Provider component owns the state update. The children are
+    // passed in from above, so they are not re-created when the Provider
+    // re-renders — this means the Suspense boundary bails out, exercising
+    // the lazy context propagation path where the bug manifests.
+    const Context = React.createContext(null);
+    const neverResolvingPromise = new Promise(() => {});
+    const resolvedThenable = {status: 'fulfilled', value: 'Result', then() {}};
+
+    function Consumer() {
+      return <Text text={use(use(Context))} />;
+    }
+
+    let setPromise;
+    function Provider({children}) {
+      const [promise, _setPromise] = useState(neverResolvingPromise);
+      setPromise = _setPromise;
+      return <Context.Provider value={promise}>{children}</Context.Provider>;
+    }
+
+    const root = ReactNoop.createRoot();
+    await act(() => {
+      root.render(
+        <Provider>
+          <Suspense fallback={<Text text="Loading" />}>
+            <Consumer />
+          </Suspense>
+        </Provider>,
+      );
+    });
+    assertLog(['Loading']);
+    expect(root).toMatchRenderedOutput('Loading');
+
+    await act(() => {
+      setPromise(resolvedThenable);
+    });
+    assertLog(['Result']);
+    expect(root).toMatchRenderedOutput('Result');
+  });
+
+  it('regression: context change triggers retry of suspended Suspense boundary on initial mount (nested)', async () => {
+    // Same as above, but with an additional indirection component between
+    // the provider and the Suspense boundary. This exercises the
+    // propagateContextChanges walker path rather than the
+    // propagateParentContextChanges path.
+    const Context = React.createContext(null);
+    const neverResolvingPromise = new Promise(() => {});
+    const resolvedThenable = {status: 'fulfilled', value: 'Result', then() {}};
+
+    function Consumer() {
+      return <Text text={use(use(Context))} />;
+    }
+
+    function Indirection({children}) {
+      Scheduler.log('Indirection');
+      return children;
+    }
+
+    let setPromise;
+    function Provider({children}) {
+      const [promise, _setPromise] = useState(neverResolvingPromise);
+      setPromise = _setPromise;
+      return <Context.Provider value={promise}>{children}</Context.Provider>;
+    }
+
+    const root = ReactNoop.createRoot();
+    await act(() => {
+      root.render(
+        <Provider>
+          <Indirection>
+            <Suspense fallback={<Text text="Loading" />}>
+              <Consumer />
+            </Suspense>
+          </Indirection>
+        </Provider>,
+      );
+    });
+    assertLog(['Indirection', 'Loading']);
+    expect(root).toMatchRenderedOutput('Loading');
+
+    // Indirection should not re-render — only the Suspense boundary
+    // should be retried.
+    await act(() => {
+      setPromise(resolvedThenable);
+    });
+    assertLog(['Result']);
+    expect(root).toMatchRenderedOutput('Result');
+  });
 });