[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

@@ -174,17 +174,17 @@ These passes already accumulate errors internally and return `Result<void, Compi
   - Record errors on env
   - Update Pipeline.ts call site (line 315): remove `.unwrap()`
 
-- [ ] **4.10 `validateMemoizedEffectDependencies`** (`src/Validation/ValidateMemoizedEffectDependencies.ts`)
+- [x] **4.10 `validateMemoizedEffectDependencies`** (`src/Validation/ValidateMemoizedEffectDependencies.ts`)
   - Change signature to return void (note: operates on `ReactiveFunction`)
   - Record errors on the function's env
   - Update Pipeline.ts call site (line 565): remove `.unwrap()`
 
-- [ ] **4.11 `validatePreservedManualMemoization`** (`src/Validation/ValidatePreservedManualMemoization.ts`)
+- [x] **4.11 `validatePreservedManualMemoization`** (`src/Validation/ValidatePreservedManualMemoization.ts`)
   - Change signature to return void (note: operates on `ReactiveFunction`)
   - Record errors on the function's env
   - Update Pipeline.ts call site (line 572): remove `.unwrap()`
 
-- [ ] **4.12 `validateSourceLocations`** (`src/Validation/ValidateSourceLocations.ts`)
+- [x] **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.
 
-- [ ] **4.17 `validateContextVariableLValues`** (`src/Validation/ValidateContextVariableLValues.ts`)
+- [x] **4.17 `validateContextVariableLValues`** (`src/Validation/ValidateContextVariableLValues.ts`)
   - Currently throws via `CompilerError.throwTodo()` and `CompilerError.invariant()`
   - Change to record Todo errors on env and continue
   - Keep invariant throws (those indicate internal bugs)
 
-- [ ] **4.18 `validateLocalsNotReassignedAfterRender`** (`src/Validation/ValidateLocalsNotReassignedAfterRender.ts`)
+- [x] **4.18 `validateLocalsNotReassignedAfterRender`** (`src/Validation/ValidateLocalsNotReassignedAfterRender.ts`)
   - Currently constructs a `CompilerError` and `throw`s it directly
   - Change to record errors on env
 
-- [ ] **4.19 `validateNoDerivedComputationsInEffects`** (`src/Validation/ValidateNoDerivedComputationsInEffects.ts`)
+- [x] **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.
 
-- [ ] **5.1 `inferMutationAliasingEffects`** (`src/Inference/InferMutationAliasingEffects.ts`)
+- [x] **5.1 `inferMutationAliasingEffects`** (`src/Inference/InferMutationAliasingEffects.ts`)
   - Currently returns `Result<void, CompilerError>` — errors are about mutation of frozen/global values
   - Change to record errors on `fn.env` instead of accumulating internally
   - **Key recovery strategy**: When a mutation of a frozen value is detected, record the error but treat the operation as a non-mutating read. This way downstream passes see a consistent (if conservative) view
   - When a mutation of a global is detected, record the error but continue with the global unchanged
   - Update Pipeline.ts (lines 233-239): remove the conditional `.isErr()` / throw pattern
 
-- [ ] **5.2 `inferMutationAliasingRanges`** (`src/Inference/InferMutationAliasingRanges.ts`)
+- [x] **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
 
-- [ ] **6.1 `codegenFunction`** (`src/ReactiveScopes/CodegenReactiveFunction.ts`)
+- [x] **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:

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

@@ -164,9 +164,7 @@ function runWithEnvironment(
   });
   log({kind: 'hir', name: 'PruneMaybeThrows', value: hir});
 
-  env.tryRecord(() => {
-    validateContextVariableLValues(hir);
-  });
+  validateContextVariableLValues(hir);
   validateUseMemo(hir);
 
   if (env.enableDropManualMemoization) {
@@ -232,13 +230,8 @@ function runWithEnvironment(
   });
   log({kind: 'hir', name: 'AnalyseFunctions', value: hir});
 
-  const mutabilityAliasingErrors = inferMutationAliasingEffects(hir);
+  inferMutationAliasingEffects(hir);
   log({kind: 'hir', name: 'InferMutationAliasingEffects', value: hir});
-  if (env.enableValidations) {
-    if (mutabilityAliasingErrors.isErr()) {
-      env.recordErrors(mutabilityAliasingErrors.unwrapErr());
-    }
-  }
 
   if (env.outputMode === 'ssr') {
     env.tryRecord(() => {
@@ -257,17 +250,12 @@ function runWithEnvironment(
   });
   log({kind: 'hir', name: 'PruneMaybeThrows', value: hir});
 
-  const mutabilityAliasingRangeErrors = inferMutationAliasingRanges(hir, {
+  inferMutationAliasingRanges(hir, {
     isFunctionExpression: false,
   });
   log({kind: 'hir', name: 'InferMutationAliasingRanges', value: hir});
   if (env.enableValidations) {
-    if (mutabilityAliasingRangeErrors.isErr()) {
-      env.recordErrors(mutabilityAliasingRangeErrors.unwrapErr());
-    }
-    env.tryRecord(() => {
-      validateLocalsNotReassignedAfterRender(hir);
-    });
+    validateLocalsNotReassignedAfterRender(hir);
   }
 
   if (env.enableValidations) {
@@ -289,9 +277,7 @@ function runWithEnvironment(
     ) {
       env.logErrors(validateNoDerivedComputationsInEffects_exp(hir));
     } else if (env.config.validateNoDerivedComputationsInEffects) {
-      env.tryRecord(() => {
-        validateNoDerivedComputationsInEffects(hir);
-      });
+      validateNoDerivedComputationsInEffects(hir);
     }
 
     if (env.config.validateNoSetStateInEffects && env.outputMode === 'lint') {
@@ -608,29 +594,20 @@ function runWithEnvironment(
     env.config.enablePreserveExistingMemoizationGuarantees ||
     env.config.validatePreserveExistingMemoizationGuarantees
   ) {
-    env.tryRecord(() => {
-      validatePreservedManualMemoization(reactiveFunction).unwrap();
-    });
+    validatePreservedManualMemoization(reactiveFunction);
   }
 
-  const codegenResult = codegenFunction(reactiveFunction, {
+  const ast = 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) {
-    env.tryRecord(() => {
-      validateSourceLocations(func, ast).unwrap();
-    });
+    validateSourceLocations(func, ast, env);
   }
 
   /**

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

@@ -724,7 +724,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/Inference/AnalyseFunctions.ts

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

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

@@ -45,7 +45,7 @@ import {
   eachTerminalOperand,
   eachTerminalSuccessor,
 } from '../HIR/visitors';
-import {Ok, Result} from '../Utils/Result';
+
 import {
   assertExhaustive,
   getOrInsertDefault,
@@ -100,7 +100,7 @@ export function inferMutationAliasingEffects(
   {isFunctionExpression}: {isFunctionExpression: boolean} = {
     isFunctionExpression: false,
   },
-): Result<void, CompilerError> {
+): void {
   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 Ok(undefined);
+  return;
 }
 
 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},
-): Result<Array<AliasingEffect>, CompilerError> {
+): Array<AliasingEffect> {
   // The set of externally-visible effects
   const functionEffects: Array<AliasingEffect> = [];
 
@@ -547,10 +547,14 @@ export function inferMutationAliasingRanges(
     }
   }
 
-  if (errors.hasAnyErrors() && !isFunctionExpression) {
-    return Err(errors);
+  if (
+    errors.hasAnyErrors() &&
+    !isFunctionExpression &&
+    fn.env.enableValidations
+  ) {
+    fn.env.recordErrors(errors);
   }
-  return Ok(functionEffects);
+  return 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>;
   },
-): Result<CodegenFunction, CompilerError> {
+): CodegenFunction {
   const cx = new Context(
     fn.env,
     fn.id ?? '[[ anonymous ]]',
@@ -141,11 +141,7 @@ export function codegenFunction(
     };
   }
 
-  const compileResult = codegenReactiveFunction(cx, fn);
-  if (compileResult.isErr()) {
-    return compileResult;
-  }
-  const compiled = compileResult.unwrap();
+  const compiled = codegenReactiveFunction(cx, fn);
 
   const hookGuard = fn.env.config.enableEmitHookGuards;
   if (hookGuard != null && fn.env.outputMode === 'client') {
@@ -273,7 +269,7 @@ export function codegenFunction(
         emitInstrumentForget.globalGating,
       );
       if (assertResult.isErr()) {
-        return assertResult;
+        fn.env.recordErrors(assertResult.unwrapErr());
       }
     }
 
@@ -323,20 +319,17 @@ export function codegenFunction(
       ),
       reactiveFunction,
     );
-    if (codegen.isErr()) {
-      return codegen;
-    }
-    outlined.push({fn: codegen.unwrap(), type});
+    outlined.push({fn: codegen, type});
   }
   compiled.outlined = outlined;
 
-  return compileResult;
+  return compiled;
 }
 
 function codegenReactiveFunction(
   cx: Context,
   fn: ReactiveFunction,
-): Result<CodegenFunction, CompilerError> {
+): CodegenFunction {
   for (const param of fn.params) {
     const place = param.kind === 'Identifier' ? param : param.place;
     cx.temp.set(place.identifier.declarationId, null);
@@ -355,13 +348,13 @@ function codegenReactiveFunction(
   }
 
   if (cx.errors.hasAnyErrors()) {
-    return Err(cx.errors);
+    fn.env.recordErrors(cx.errors);
   }
 
   const countMemoBlockVisitor = new CountMemoBlockVisitor(fn.env);
   visitReactiveFunction(fn, countMemoBlockVisitor, undefined);
 
-  return Ok({
+  return {
     type: 'CodegenFunction',
     loc: fn.loc,
     id: fn.id !== null ? t.identifier(fn.id) : null,
@@ -376,7 +369,7 @@ function codegenReactiveFunction(
     prunedMemoBlocks: countMemoBlockVisitor.prunedMemoBlocks,
     prunedMemoValues: countMemoBlockVisitor.prunedMemoValues,
     outlined: [],
-  });
+  };
 }
 
 class CountMemoBlockVisitor extends ReactiveFunctionVisitor<void> {
@@ -1665,7 +1658,7 @@ function codegenInstructionValue(
                   cx.temp,
                 ),
                 reactiveFunction,
-              ).unwrap();
+              );
 
               /*
                * ObjectMethod builder must be backwards compatible with older versions of babel.
@@ -1864,7 +1857,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,7 +5,9 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import {CompilerError} from '..';
+import {CompilerDiagnostic, CompilerError} from '..';
+import {ErrorCategory} from '../CompilerError';
+import {Environment} from '../HIR/Environment';
 import {HIRFunction, IdentifierId, Place} from '../HIR';
 import {printPlace} from '../HIR/PrintHIR';
 import {eachInstructionValueLValue, eachPatternOperand} from '../HIR/visitors';
@@ -17,12 +19,13 @@ import {eachInstructionValueLValue, eachPatternOperand} from '../HIR/visitors';
  */
 export function validateContextVariableLValues(fn: HIRFunction): void {
   const identifierKinds: IdentifierKinds = new Map();
-  validateContextVariableLValuesImpl(fn, identifierKinds);
+  validateContextVariableLValuesImpl(fn, identifierKinds, fn.env);
 }
 
 function validateContextVariableLValuesImpl(
   fn: HIRFunction,
   identifierKinds: IdentifierKinds,
+  env: Environment,
 ): void {
   for (const [, block] of fn.body.blocks) {
     for (const instr of block.instructions) {
@@ -30,30 +33,30 @@ function validateContextVariableLValuesImpl(
       switch (value.kind) {
         case 'DeclareContext':
         case 'StoreContext': {
-          visit(identifierKinds, value.lvalue.place, 'context');
+          visit(identifierKinds, value.lvalue.place, 'context', env);
           break;
         }
         case 'LoadContext': {
-          visit(identifierKinds, value.place, 'context');
+          visit(identifierKinds, value.place, 'context', env);
           break;
         }
         case 'StoreLocal':
         case 'DeclareLocal': {
-          visit(identifierKinds, value.lvalue.place, 'local');
+          visit(identifierKinds, value.lvalue.place, 'local', env);
           break;
         }
         case 'LoadLocal': {
-          visit(identifierKinds, value.place, 'local');
+          visit(identifierKinds, value.place, 'local', env);
           break;
         }
         case 'PostfixUpdate':
         case 'PrefixUpdate': {
-          visit(identifierKinds, value.lvalue, 'local');
+          visit(identifierKinds, value.lvalue, 'local', env);
           break;
         }
         case 'Destructure': {
           for (const lvalue of eachPatternOperand(value.lvalue.pattern)) {
-            visit(identifierKinds, lvalue, 'destructure');
+            visit(identifierKinds, lvalue, 'destructure', env);
           }
           break;
         }
@@ -62,18 +65,24 @@ function validateContextVariableLValuesImpl(
           validateContextVariableLValuesImpl(
             value.loweredFunc.func,
             identifierKinds,
+            env,
           );
           break;
         }
         default: {
           for (const _ of eachInstructionValueLValue(value)) {
-            CompilerError.throwTodo({
-              reason:
-                'ValidateContextVariableLValues: unhandled instruction variant',
-              loc: value.loc,
-              description: `Handle '${value.kind} lvalues`,
-              suggestions: null,
-            });
+            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,
+              }),
+            );
           }
         }
       }
@@ -90,6 +99,7 @@ function visit(
   identifiers: IdentifierKinds,
   place: Place,
   kind: 'local' | 'context' | 'destructure',
+  env: Environment,
 ): void {
   const prev = identifiers.get(place.identifier.id);
   if (prev !== undefined) {
@@ -97,12 +107,18 @@ function visit(
     const isContext = kind === 'context';
     if (wasContext !== isContext) {
       if (prev.kind === 'destructure' || kind === 'destructure') {
-        CompilerError.throwTodo({
-          reason: `Support destructuring of context variables`,
-          loc: kind === 'destructure' ? place.loc : prev.place.loc,
-          description: null,
-          suggestions: null,
-        });
+        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.invariant(false, {

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

@@ -7,6 +7,7 @@
 
 import {CompilerDiagnostic, CompilerError, Effect} from '..';
 import {ErrorCategory} from '../CompilerError';
+import {Environment} from '../HIR/Environment';
 import {HIRFunction, IdentifierId, Place} from '../HIR';
 import {
   eachInstructionLValue,
@@ -27,15 +28,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';
-    errors.pushDiagnostic(
+    fn.env.recordError(
       CompilerDiagnostic.create({
         category: ErrorCategory.Immutability,
         reason: 'Cannot reassign variable after render completes',
@@ -46,7 +47,6 @@ export function validateLocalsNotReassignedAfterRender(fn: HIRFunction): void {
         message: `Cannot reassign ${variable} after render completes`,
       }),
     );
-    throw errors;
   }
 }
 
@@ -55,6 +55,7 @@ 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) {
@@ -68,6 +69,7 @@ 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?
@@ -84,13 +86,12 @@ 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';
-              errors.pushDiagnostic(
+              env.recordError(
                 CompilerDiagnostic.create({
                   category: ErrorCategory.Immutability,
                   reason: 'Cannot reassign variable in async function',
@@ -102,7 +103,7 @@ function getContextReassignment(
                   message: `Cannot reassign ${variable}`,
                 }),
               );
-              throw errors;
+              return null;
             }
             reassigningFunctions.set(lvalue.identifier.id, reassignment);
           }

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

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

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

@@ -37,7 +37,6 @@ import {
   ReactiveFunctionVisitor,
   visitReactiveFunction,
 } from '../ReactiveScopes/visitors';
-import {Result} from '../Utils/Result';
 import {getOrInsertDefault} from '../Utils/utils';
 
 /**
@@ -47,15 +46,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,
-): Result<void, CompilerError> {
+export function validatePreservedManualMemoization(fn: ReactiveFunction): void {
   const state = {
     errors: new CompilerError(),
     manualMemoState: null,
   };
   visitReactiveFunction(fn, new Visitor(), state);
-  return state.errors.asResult();
+  for (const detail of state.errors.details) {
+    fn.env.recordError(detail);
+  }
 }
 
 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 {Result} from '../Utils/Result';
+import {Environment} from '../HIR/Environment';
 
 /**
  * IMPORTANT: This validation is only intended for use in unit tests.
@@ -123,7 +123,8 @@ export function validateSourceLocations(
     t.FunctionDeclaration | t.ArrowFunctionExpression | t.FunctionExpression
   >,
   generatedAst: CodegenFunction,
-): Result<void, CompilerError> {
+  env: Environment,
+): void {
   const errors = new CompilerError();
 
   /*
@@ -309,5 +310,7 @@ export function validateSourceLocations(
     }
   }
 
-  return errors.asResult();
+  for (const detail of errors.details) {
+    env.recordError(detail);
+  }
 }

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 2 errors:
+Found 3 errors:
 
 Todo: Support destructuring of context variables
 
@@ -29,7 +29,18 @@ 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
+
+Todo: Support destructuring of context variables
+
+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