[compiler] Phase 2+7: Wrap pipeline passes in tryRecord for fault tolerance

- Change runWithEnvironment/run/compileFn to return Result<CodegenFunction, CompilerError>
- Wrap all pipeline passes in env.tryRecord() to catch and record CompilerErrors
- Record inference pass errors via env.recordErrors() instead of throwing
- Handle codegen Result explicitly, returning Err on failure
- Add final error check: return Err(env.aggregateErrors()) if any errors accumulated
- Update tryCompileFunction and retryCompileFunction in Program.ts to handle Result
- Keep lint-only passes using env.logErrors() (non-blocking)
- Update 52 test fixture expectations that now report additional errors

This is the core integration that enables fault tolerance: errors are caught,
recorded, and the pipeline continues to discover more errors.

compiler/fault-tolerance-overview.md

@@ -127,64 +127,64 @@ All validation passes need to record errors on the environment instead of return
 
 These passes already accumulate errors internally and return `Result<void, CompilerError>`. The change is: instead of returning the Result, record errors on `env` and return void. Remove the `.unwrap()` call in Pipeline.ts.
 
-- [x] **4.1 `validateHooksUsage`** (`src/Validation/ValidateHooksUsage.ts`)
+- [ ] **4.1 `validateHooksUsage`** (`src/Validation/ValidateHooksUsage.ts`)
   - Change signature from `(fn: HIRFunction): Result<void, CompilerError>` to `(fn: HIRFunction): void`
   - Record errors on `fn.env` instead of returning `errors.asResult()`
   - Update Pipeline.ts call site (line 211): remove `.unwrap()`
 
-- [x] **4.2 `validateNoCapitalizedCalls`** (`src/Validation/ValidateNoCapitalizedCalls.ts`)
+- [ ] **4.2 `validateNoCapitalizedCalls`** (`src/Validation/ValidateNoCapitalizedCalls.ts`)
   - Change signature to return void
   - Fix the hybrid pattern: the direct `CallExpression` path currently throws via `CompilerError.throwInvalidReact()` — change to record on env
   - The `MethodCall` path already accumulates — change to record on env
   - Update Pipeline.ts call site (line 214): remove `.unwrap()`
 
-- [x] **4.3 `validateUseMemo`** (`src/Validation/ValidateUseMemo.ts`)
+- [ ] **4.3 `validateUseMemo`** (`src/Validation/ValidateUseMemo.ts`)
   - Change signature to return void
   - Record hard errors on env instead of returning `errors.asResult()`
   - The soft `voidMemoErrors` path already uses `env.logErrors()` — keep as-is or also record
   - Update Pipeline.ts call site (line 170): remove `.unwrap()`
 
-- [x] **4.4 `dropManualMemoization`** (`src/Inference/DropManualMemoization.ts`)
+- [ ] **4.4 `dropManualMemoization`** (`src/Inference/DropManualMemoization.ts`)
   - Change signature to return void
   - Record errors on env instead of returning `errors.asResult()`
   - Update Pipeline.ts call site (line 178): remove `.unwrap()`
 
-- [x] **4.5 `validateNoRefAccessInRender`** (`src/Validation/ValidateNoRefAccessInRender.ts`)
+- [ ] **4.5 `validateNoRefAccessInRender`** (`src/Validation/ValidateNoRefAccessInRender.ts`)
   - Change signature to return void
   - Record errors on env instead of returning Result
   - Update Pipeline.ts call site (line 275): remove `.unwrap()`
 
-- [x] **4.6 `validateNoSetStateInRender`** (`src/Validation/ValidateNoSetStateInRender.ts`)
+- [ ] **4.6 `validateNoSetStateInRender`** (`src/Validation/ValidateNoSetStateInRender.ts`)
   - Change signature to return void
   - Record errors on env
   - Update Pipeline.ts call site (line 279): remove `.unwrap()`
 
-- [x] **4.7 `validateNoImpureFunctionsInRender`** (`src/Validation/ValidateNoImpureFunctionsInRender.ts`)
+- [ ] **4.7 `validateNoImpureFunctionsInRender`** (`src/Validation/ValidateNoImpureFunctionsInRender.ts`)
   - Change signature to return void
   - Record errors on env
   - Update Pipeline.ts call site (line 300): remove `.unwrap()`
 
-- [x] **4.8 `validateNoFreezingKnownMutableFunctions`** (`src/Validation/ValidateNoFreezingKnownMutableFunctions.ts`)
+- [ ] **4.8 `validateNoFreezingKnownMutableFunctions`** (`src/Validation/ValidateNoFreezingKnownMutableFunctions.ts`)
   - Change signature to return void
   - Record errors on env
   - Update Pipeline.ts call site (line 303): remove `.unwrap()`
 
-- [x] **4.9 `validateExhaustiveDependencies`** (`src/Validation/ValidateExhaustiveDependencies.ts`)
+- [ ] **4.9 `validateExhaustiveDependencies`** (`src/Validation/ValidateExhaustiveDependencies.ts`)
   - Change signature to return void
   - Record errors on env
   - Update Pipeline.ts call site (line 315): remove `.unwrap()`
 
-- [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
 

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

@@ -161,11 +161,17 @@ function runWithEnvironment(
   pruneMaybeThrows(hir);
   log({kind: 'hir', name: 'PruneMaybeThrows', value: hir});
 
-  validateContextVariableLValues(hir);
-  validateUseMemo(hir);
+  env.tryRecord(() => {
+    validateContextVariableLValues(hir);
+  });
+  env.tryRecord(() => {
+    validateUseMemo(hir).unwrap();
+  });
 
   if (env.enableDropManualMemoization) {
-    dropManualMemoization(hir);
+    env.tryRecord(() => {
+      dropManualMemoization(hir).unwrap();
+    });
     log({kind: 'hir', name: 'DropManualMemoization', value: hir});
   }
 
@@ -198,10 +204,14 @@ function runWithEnvironment(
 
   if (env.enableValidations) {
     if (env.config.validateHooksUsage) {
-      validateHooksUsage(hir);
+      env.tryRecord(() => {
+        validateHooksUsage(hir).unwrap();
+      });
     }
     if (env.config.validateNoCapitalizedCalls) {
-      validateNoCapitalizedCalls(hir);
+      env.tryRecord(() => {
+        validateNoCapitalizedCalls(hir).unwrap();
+      });
     }
   }
 
@@ -211,8 +221,13 @@ function runWithEnvironment(
   analyseFunctions(hir);
   log({kind: 'hir', name: 'AnalyseFunctions', value: hir});
 
-  inferMutationAliasingEffects(hir);
+  const mutabilityAliasingErrors = inferMutationAliasingEffects(hir);
   log({kind: 'hir', name: 'InferMutationAliasingEffects', value: hir});
+  if (env.enableValidations) {
+    if (mutabilityAliasingErrors.isErr()) {
+      env.recordErrors(mutabilityAliasingErrors.unwrapErr());
+    }
+  }
 
   if (env.outputMode === 'ssr') {
     optimizeForSSR(hir);
@@ -225,12 +240,17 @@ function runWithEnvironment(
   pruneMaybeThrows(hir);
   log({kind: 'hir', name: 'PruneMaybeThrows', value: hir});
 
-  inferMutationAliasingRanges(hir, {
+  const mutabilityAliasingRangeErrors = inferMutationAliasingRanges(hir, {
     isFunctionExpression: false,
   });
   log({kind: 'hir', name: 'InferMutationAliasingRanges', value: hir});
   if (env.enableValidations) {
-    validateLocalsNotReassignedAfterRender(hir);
+    if (mutabilityAliasingRangeErrors.isErr()) {
+      env.recordErrors(mutabilityAliasingRangeErrors.unwrapErr());
+    }
+    env.tryRecord(() => {
+      validateLocalsNotReassignedAfterRender(hir);
+    });
   }
 
   if (env.enableValidations) {
@@ -239,11 +259,15 @@ function runWithEnvironment(
     }
 
     if (env.config.validateRefAccessDuringRender) {
-      validateNoRefAccessInRender(hir);
+      env.tryRecord(() => {
+        validateNoRefAccessInRender(hir).unwrap();
+      });
     }
 
     if (env.config.validateNoSetStateInRender) {
-      validateNoSetStateInRender(hir);
+      env.tryRecord(() => {
+        validateNoSetStateInRender(hir).unwrap();
+      });
     }
 
     if (
@@ -252,7 +276,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') {
@@ -264,7 +290,7 @@ function runWithEnvironment(
     }
 
     env.tryRecord(() => {
-      validateNoFreezingKnownMutableFunctions(hir);
+      validateNoFreezingKnownMutableFunctions(hir).unwrap();
     });
   }
 
@@ -277,7 +303,9 @@ function runWithEnvironment(
       env.config.validateExhaustiveEffectDependencies
     ) {
       // NOTE: this relies on reactivity inference running first
-      validateExhaustiveDependencies(hir);
+      env.tryRecord(() => {
+        validateExhaustiveDependencies(hir).unwrap();
+      });
     }
   }
 
@@ -506,20 +534,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/Inference/AnalyseFunctions.ts

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

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

@@ -31,6 +31,7 @@ import {
   makeInstructionId,
 } from '../HIR';
 import {createTemporaryPlace, markInstructionIds} from '../HIR/HIRBuilder';
+import {Result} from '../Utils/Result';
 
 type ManualMemoCallee = {
   kind: 'useMemo' | 'useCallback';
@@ -388,7 +389,9 @@ function extractManualMemoizationArgs(
  * This pass also validates that useMemo callbacks return a value (not void), ensuring that useMemo
  * is only used for memoizing values and not for running arbitrary side effects.
  */
-export function dropManualMemoization(func: HIRFunction): void {
+export function dropManualMemoization(
+  func: HIRFunction,
+): Result<void, CompilerError> {
   const errors = new CompilerError();
   const isValidationEnabled =
     func.env.config.validatePreserveExistingMemoizationGuarantees ||
@@ -550,9 +553,7 @@ export function dropManualMemoization(func: HIRFunction): void {
     }
   }
 
-  if (errors.hasAnyErrors()) {
-    func.env.recordErrors(errors);
-  }
+  return errors.asResult();
 }
 
 function findOptionalPlaces(fn: HIRFunction): Set<IdentifierId> {

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

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

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

@@ -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/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> {
@@ -1658,7 +1665,7 @@ function codegenInstructionValue(
                   cx.temp,
                 ),
                 reactiveFunction,
-              );
+              ).unwrap();
 
               /*
                * ObjectMethod builder must be backwards compatible with older versions of babel.
@@ -1857,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/ValidateExhaustiveDependencies.ts

@@ -44,6 +44,7 @@ import {
   eachInstructionValueOperand,
   eachTerminalOperand,
 } from '../HIR/visitors';
+import {Result} from '../Utils/Result';
 import {retainWhere} from '../Utils/utils';
 
 const DEBUG = false;
@@ -87,7 +88,9 @@ const DEBUG = false;
  * When we go to compute the dependencies, we then think that the user's manual dep
  * logic is part of what the memo computation logic.
  */
-export function validateExhaustiveDependencies(fn: HIRFunction): void {
+export function validateExhaustiveDependencies(
+  fn: HIRFunction,
+): Result<void, CompilerError> {
   const env = fn.env;
   const reactive = collectReactiveIdentifiersHIR(fn);
 
@@ -214,9 +217,7 @@ export function validateExhaustiveDependencies(fn: HIRFunction): void {
     },
     false, // isFunctionExpression
   );
-  if (error.hasAnyErrors()) {
-    fn.env.recordErrors(error);
-  }
+  return error.asResult();
 }
 
 function validateDependencies(

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

@@ -26,6 +26,7 @@ import {
   eachTerminalOperand,
 } from '../HIR/visitors';
 import {assertExhaustive} from '../Utils/utils';
+import {Result} from '../Utils/Result';
 
 /**
  * Represents the possible kinds of value which may be stored at a given Place during
@@ -87,7 +88,9 @@ function joinKinds(a: Kind, b: Kind): Kind {
  *   may not appear as the callee of a conditional call.
  *   See the note for Kind.PotentialHook for sources of potential hooks
  */
-export function validateHooksUsage(fn: HIRFunction): void {
+export function validateHooksUsage(
+  fn: HIRFunction,
+): Result<void, CompilerError> {
   const unconditionalBlocks = computeUnconditionalBlocks(fn);
 
   const errors = new CompilerError();
@@ -423,9 +426,7 @@ export function validateHooksUsage(fn: HIRFunction): void {
   for (const [, error] of errorsByPlace) {
     errors.pushErrorDetail(error);
   }
-  if (errors.hasAnyErrors()) {
-    fn.env.recordErrors(errors);
-  }
+  return errors.asResult();
 }
 
 function visitFunctionExpression(errors: CompilerError, fn: HIRFunction): void {

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

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

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

@@ -5,12 +5,15 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import {CompilerError, CompilerErrorDetail, EnvironmentConfig} from '..';
+import {CompilerError, EnvironmentConfig} from '..';
 import {ErrorCategory} from '../CompilerError';
 import {HIRFunction, IdentifierId} from '../HIR';
 import {DEFAULT_GLOBALS} from '../HIR/Globals';
+import {Result} from '../Utils/Result';
 
-export function validateNoCapitalizedCalls(fn: HIRFunction): void {
+export function validateNoCapitalizedCalls(
+  fn: HIRFunction,
+): Result<void, CompilerError> {
   const envConfig: EnvironmentConfig = fn.env.config;
   const ALLOW_LIST = new Set([
     ...DEFAULT_GLOBALS.keys(),
@@ -45,16 +48,13 @@ export function validateNoCapitalizedCalls(fn: HIRFunction): void {
           const calleeIdentifier = value.callee.identifier.id;
           const calleeName = capitalLoadGlobals.get(calleeIdentifier);
           if (calleeName != null) {
-            fn.env.recordError(
-              new CompilerErrorDetail({
-                category: ErrorCategory.CapitalizedCalls,
-                reason,
-                description: `${calleeName} may be a component`,
-                loc: value.loc,
-                suggestions: null,
-              }),
-            );
-            continue;
+            CompilerError.throwInvalidReact({
+              category: ErrorCategory.CapitalizedCalls,
+              reason,
+              description: `${calleeName} may be a component`,
+              loc: value.loc,
+              suggestions: null,
+            });
           }
           break;
         }
@@ -85,7 +85,5 @@ export function validateNoCapitalizedCalls(fn: HIRFunction): void {
       }
     }
   }
-  if (errors.hasAnyErrors()) {
-    fn.env.recordErrors(errors);
-  }
+  return errors.asResult();
 }

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

@@ -97,8 +97,8 @@ export function validateNoDerivedComputationsInEffects(fn: HIRFunction): void {
       }
     }
   }
-  for (const detail of errors.details) {
-    fn.env.recordError(detail);
+  if (errors.hasAnyErrors()) {
+    throw errors;
   }
 }
 

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

@@ -18,6 +18,7 @@ import {
   eachTerminalOperand,
 } from '../HIR/visitors';
 import {AliasingEffect} from '../Inference/AliasingEffects';
+import {Result} from '../Utils/Result';
 
 /**
  * Validates that functions with known mutations (ie due to types) cannot be passed
@@ -42,7 +43,9 @@ import {AliasingEffect} from '../Inference/AliasingEffects';
  * This pass detects functions with *known* mutations (Store or Mutate, not ConditionallyMutate)
  * that are passed where a frozen value is expected and rejects them.
  */
-export function validateNoFreezingKnownMutableFunctions(fn: HIRFunction): void {
+export function validateNoFreezingKnownMutableFunctions(
+  fn: HIRFunction,
+): Result<void, CompilerError> {
   const errors = new CompilerError();
   const contextMutationEffects: Map<
     IdentifierId,
@@ -159,7 +162,5 @@ export function validateNoFreezingKnownMutableFunctions(fn: HIRFunction): void {
       visitOperand(operand);
     }
   }
-  if (errors.hasAnyErrors()) {
-    fn.env.recordErrors(errors);
-  }
+  return errors.asResult();
 }

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

@@ -9,6 +9,7 @@ import {CompilerDiagnostic, CompilerError} from '..';
 import {ErrorCategory} from '../CompilerError';
 import {HIRFunction} from '../HIR';
 import {getFunctionCallSignature} from '../Inference/InferMutationAliasingEffects';
+import {Result} from '../Utils/Result';
 
 /**
  * Checks that known-impure functions are not called during render. Examples of invalid functions to
@@ -19,7 +20,9 @@ import {getFunctionCallSignature} from '../Inference/InferMutationAliasingEffect
  * this in several of our validation passes and should unify those analyses into a reusable helper
  * and use it here.
  */
-export function validateNoImpureFunctionsInRender(fn: HIRFunction): void {
+export function validateNoImpureFunctionsInRender(
+  fn: HIRFunction,
+): Result<void, CompilerError> {
   const errors = new CompilerError();
   for (const [, block] of fn.body.blocks) {
     for (const instr of block.instructions) {
@@ -52,7 +55,5 @@ export function validateNoImpureFunctionsInRender(fn: HIRFunction): void {
       }
     }
   }
-  if (errors.hasAnyErrors()) {
-    fn.env.recordErrors(errors);
-  }
+  return errors.asResult();
 }

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

@@ -27,6 +27,7 @@ import {
   eachPatternOperand,
   eachTerminalOperand,
 } from '../HIR/visitors';
+import {Err, Ok, Result} from '../Utils/Result';
 import {retainWhere} from '../Utils/utils';
 
 /**
@@ -119,14 +120,12 @@ class Env {
   }
 }
 
-export function validateNoRefAccessInRender(fn: HIRFunction): void {
+export function validateNoRefAccessInRender(
+  fn: HIRFunction,
+): Result<void, CompilerError> {
   const env = new Env();
   collectTemporariesSidemap(fn, env);
-  const errors = new CompilerError();
-  validateNoRefAccessInRenderImpl(fn, env, errors);
-  if (errors.hasAnyErrors()) {
-    fn.env.recordErrors(errors);
-  }
+  return validateNoRefAccessInRenderImpl(fn, env).map(_ => undefined);
 }
 
 function collectTemporariesSidemap(fn: HIRFunction, env: Env): void {
@@ -306,8 +305,7 @@ function joinRefAccessTypes(...types: Array<RefAccessType>): RefAccessType {
 function validateNoRefAccessInRenderImpl(
   fn: HIRFunction,
   env: Env,
-  errors: CompilerError,
-): RefAccessType {
+): Result<RefAccessType, CompilerError> {
   let returnValues: Array<undefined | RefAccessType> = [];
   let place;
   for (const param of fn.params) {
@@ -338,6 +336,7 @@ function validateNoRefAccessInRenderImpl(
     env.resetChanged();
     returnValues = [];
     const safeBlocks: Array<{block: BlockId; ref: RefId}> = [];
+    const errors = new CompilerError();
     for (const [, block] of fn.body.blocks) {
       retainWhere(safeBlocks, entry => entry.block !== block.id);
       for (const phi of block.phis) {
@@ -433,15 +432,13 @@ function validateNoRefAccessInRenderImpl(
           case 'FunctionExpression': {
             let returnType: RefAccessType = {kind: 'None'};
             let readRefEffect = false;
-            const innerErrors = new CompilerError();
             const result = validateNoRefAccessInRenderImpl(
               instr.value.loweredFunc.func,
               env,
-              innerErrors,
             );
-            if (!innerErrors.hasAnyErrors()) {
-              returnType = result;
-            } else {
+            if (result.isOk()) {
+              returnType = result.unwrap();
+            } else if (result.isErr()) {
               readRefEffect = true;
             }
             env.set(instr.lvalue.identifier.id, {
@@ -732,7 +729,7 @@ function validateNoRefAccessInRenderImpl(
     }
 
     if (errors.hasAnyErrors()) {
-      return {kind: 'None'};
+      return Err(errors);
     }
   }
 
@@ -741,8 +738,10 @@ function validateNoRefAccessInRenderImpl(
     loc: GeneratedSource,
   });
 
-  return joinRefAccessTypes(
-    ...returnValues.filter((env): env is RefAccessType => env !== undefined),
+  return Ok(
+    joinRefAccessTypes(
+      ...returnValues.filter((env): env is RefAccessType => env !== undefined),
+    ),
   );
 }
 

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

@@ -13,6 +13,7 @@ import {
 import {HIRFunction, IdentifierId, isSetStateType} from '../HIR';
 import {computeUnconditionalBlocks} from '../HIR/ComputeUnconditionalBlocks';
 import {eachInstructionValueOperand} from '../HIR/visitors';
+import {Result} from '../Utils/Result';
 
 /**
  * Validates that the given function does not have an infinite update loop
@@ -42,21 +43,17 @@ import {eachInstructionValueOperand} from '../HIR/visitors';
  * y();
  * ```
  */
-export function validateNoSetStateInRender(fn: HIRFunction): void {
+export function validateNoSetStateInRender(
+  fn: HIRFunction,
+): Result<void, CompilerError> {
   const unconditionalSetStateFunctions: Set<IdentifierId> = new Set();
-  const errors = validateNoSetStateInRenderImpl(
-    fn,
-    unconditionalSetStateFunctions,
-  );
-  if (errors.hasAnyErrors()) {
-    fn.env.recordErrors(errors);
-  }
+  return validateNoSetStateInRenderImpl(fn, unconditionalSetStateFunctions);
 }
 
 function validateNoSetStateInRenderImpl(
   fn: HIRFunction,
   unconditionalSetStateFunctions: Set<IdentifierId>,
-): CompilerError {
+): Result<void, CompilerError> {
   const unconditionalBlocks = computeUnconditionalBlocks(fn);
   let activeManualMemoId: number | null = null;
   const errors = new CompilerError();
@@ -95,7 +92,7 @@ function validateNoSetStateInRenderImpl(
             validateNoSetStateInRenderImpl(
               instr.value.loweredFunc.func,
               unconditionalSetStateFunctions,
-            ).hasAnyErrors()
+            ).isErr()
           ) {
             // This function expression unconditionally calls a setState
             unconditionalSetStateFunctions.add(instr.lvalue.identifier.id);
@@ -186,5 +183,5 @@ function validateNoSetStateInRenderImpl(
     }
   }
 
-  return errors;
+  return errors.asResult();
 }

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,15 +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);
-  for (const detail of state.errors.details) {
-    fn.env.recordError(detail);
-  }
+  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,7 +309,5 @@ export function validateSourceLocations(
     }
   }
 
-  for (const detail of errors.details) {
-    env.recordError(detail);
-  }
+  return errors.asResult();
 }

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

@@ -20,8 +20,9 @@ import {
   eachInstructionValueOperand,
   eachTerminalOperand,
 } from '../HIR/visitors';
+import {Result} from '../Utils/Result';
 
-export function validateUseMemo(fn: HIRFunction): void {
+export function validateUseMemo(fn: HIRFunction): Result<void, CompilerError> {
   const errors = new CompilerError();
   const voidMemoErrors = new CompilerError();
   const useMemos = new Set<IdentifierId>();
@@ -176,9 +177,7 @@ export function validateUseMemo(fn: HIRFunction): void {
     }
   }
   fn.env.logErrors(voidMemoErrors.asResult());
-  if (errors.hasAnyErrors()) {
-    fn.env.recordErrors(errors);
-  }
+  return errors.asResult();
 }
 
 function validateNoContextVariableAssignment(

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

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