[compiler] Fix Pipeline.ts early-exit, formatting, and style issues

Fix the transformFire early-exit in Pipeline.ts to only trigger on new
errors from transformFire itself, not pre-existing errors from earlier
passes. The previous `env.hasErrors()` check was too broad — it would
early-exit on validation errors that existed before transformFire ran.

Also add missing blank line in CodegenReactiveFunction.ts Context class,
and fix formatting in ValidateMemoizedEffectDependencies.ts.

compiler/fault-tolerance-overview.md

@@ -328,4 +328,6 @@ Walk through `runWithEnvironment` and wrap each pass call site. This is the inte
 * **Partial HIR can trigger downstream invariants.** When lowering skips or partially handles constructs (e.g., unreachable hoisted functions, `var` declarations before the fix), downstream passes like `InferMutationAliasingEffects` may encounter uninitialized identifiers and throw invariants. This is acceptable since the function still correctly bails out of compilation, but error messages may be less specific. The fix for `var` (treating as `let`) demonstrates how to avoid this: continue lowering with a best-effort representation rather than skipping entirely.
 * **Errors accumulated on `env` are lost when an invariant propagates out of the pipeline.** Since invariant CompilerErrors always re-throw through `tryRecord()`, they exit the pipeline as exceptions. The caller only sees the invariant error, not any errors previously recorded on `env`. This is a design limitation that could be addressed by aggregating env errors with caught exceptions in `tryCompileFunction()`.
 * **Dedicated fault tolerance test fixtures** were added in `__tests__/fixtures/compiler/fault-tolerance/`. Each fixture combines two or more errors from different passes to verify the compiler reports all of them rather than short-circuiting on the first. Coverage includes: `var`+props mutation (BuildHIR→InferMutationAliasingEffects), `var`+ref access (BuildHIR→ValidateNoRefAccessInRender), `try/finally`+props mutation (BuildHIR→InferMutationAliasingEffects), `try/finally`+ref access (BuildHIR→ValidateNoRefAccessInRender), and a 3-error test combining try/finally+ref access+props mutation.
+* **Cleanup: consistent `tryRecord()` wrapping in Pipeline.ts.** All validation passes and inference passes are now wrapped in `env.tryRecord()` for defense-in-depth, consistent with the approach used for transform passes. Previously only transform passes were wrapped. Merged duplicate `env.enableValidations` guard blocks. Pattern B lint-only passes (`env.logErrors()`) were intentionally not wrapped since they use a different error recording strategy.
+* **Cleanup: normalized validation error recording pattern.** Four validation passes (`ValidateNoDerivedComputationsInEffects`, `ValidateMemoizedEffectDependencies`, `ValidatePreservedManualMemoization`, `ValidateSourceLocations`) were using `for (const detail of errors.details) { env.recordError(detail); }` instead of the simpler `env.recordErrors(errors)`. Normalized to use the batch method.
 

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

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

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

@@ -13,7 +13,6 @@ import {CompilerError} from '../CompilerError';
 import {Err, Ok, Result} from '../Utils/Result';
 import {
   HIRFunction,
-  IdentifierId,
   ReactiveFunction,
   assertConsistentIdentifiers,
   assertTerminalPredsExist,
@@ -159,9 +158,7 @@ function runWithEnvironment(
   const hir = lower(func, env);
   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, {
@@ -256,9 +231,7 @@ function runWithEnvironment(
   log({kind: 'hir', name: 'InferMutationAliasingRanges', value: hir});
   if (env.enableValidations) {
     validateLocalsNotReassignedAfterRender(hir);
-  }
 
-  if (env.enableValidations) {
     if (env.config.assertValidMutableRanges) {
       assertValidMutableRanges(hir);
     }
@@ -295,9 +268,7 @@ function runWithEnvironment(
     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,11 @@ 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);
-  });
+  const fbtOperands = memoizeFbtAndMacroOperandsInSameScope(hir);
   log({
     kind: 'hir',
     name: 'MemoizeFbtAndMacroOperandsInSameScope',
@@ -350,15 +314,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 +327,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 +367,7 @@ function runWithEnvironment(
   });
   assertValidBlockNesting(hir);
 
-  env.tryRecord(() => {
-    buildReactiveScopeTerminalsHIR(hir);
-  });
+  buildReactiveScopeTerminalsHIR(hir);
   log({
     kind: 'hir',
     name: 'BuildReactiveScopeTerminalsHIR',
@@ -430,18 +376,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,19 +391,15 @@ function runWithEnvironment(
   });
   assertTerminalSuccessorsExist(hir);
   assertTerminalPredsExist(hir);
-  env.tryRecord(() => {
-    propagateScopeDependenciesHIR(hir);
-  });
+
+  propagateScopeDependenciesHIR(hir);
   log({
     kind: 'hir',
     name: 'PropagateScopeDependenciesHIR',
     value: hir,
   });
 
-  let reactiveFunction!: ReactiveFunction;
-  env.tryRecord(() => {
-    reactiveFunction = buildReactiveFunction(hir);
-  });
+  const reactiveFunction = buildReactiveFunction(hir);
   log({
     kind: 'reactive',
     name: 'BuildReactiveFunction',
@@ -470,9 +408,7 @@ function runWithEnvironment(
 
   assertWellFormedBreakTargets(reactiveFunction);
 
-  env.tryRecord(() => {
-    pruneUnusedLabels(reactiveFunction);
-  });
+  pruneUnusedLabels(reactiveFunction);
   log({
     kind: 'reactive',
     name: 'PruneUnusedLabels',
@@ -480,109 +416,84 @@ 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',
     value: reactiveFunction,
   });
 
-  let uniqueIdentifiers: Set<string> = new Set();
-  env.tryRecord(() => {
-    uniqueIdentifiers = renameVariables(reactiveFunction);
-  });
+  const uniqueIdentifiers = renameVariables(reactiveFunction);
   log({
     kind: 'reactive',
     name: 'RenameVariables',
     value: reactiveFunction,
   });
 
-  env.tryRecord(() => {
-    pruneHoistedContexts(reactiveFunction);
-  });
+  pruneHoistedContexts(reactiveFunction);
   log({
     kind: 'reactive',
     name: 'PruneHoistedContexts',

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

@@ -720,11 +720,24 @@ function tryCompileFunction(
       return {kind: 'error', error: result.unwrapErr()};
     }
   } catch (err) {
+    /**
+     * A pass incorrectly threw instead of recording the error.
+     * Log for detection in development.
+     */
+    if (
+      err instanceof CompilerError &&
+      err.details.every(detail => detail.category !== ErrorCategory.Invariant)
+    ) {
+      programContext.logEvent({
+        kind: 'CompileUnexpectedThrow',
+        fnLoc: fn.node.loc ?? null,
+        data: err.toString(),
+      });
+    }
     return {kind: 'error', error: err};
   }
 }
 
-
 /**
  * Applies React Compiler generated functions to the babel AST by replacing
  * existing functions in place or inserting new declarations.

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

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

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

@@ -773,29 +773,6 @@ export class Environment {
     return this.#errors;
   }
 
-  /**
-   * Wraps a callback in try/catch: if the callback throws a CompilerError
-   * that is NOT an invariant, the error is recorded and execution continues.
-   * Non-CompilerError exceptions and invariants are re-thrown.
-   */
-  tryRecord(fn: () => void): void {
-    try {
-      fn();
-    } catch (err) {
-      if (err instanceof CompilerError) {
-        // Check if any detail is an invariant — if so, re-throw
-        for (const detail of err.details) {
-          if (detail.category === ErrorCategory.Invariant) {
-            throw err;
-          }
-        }
-        this.recordErrors(err);
-      } else {
-        throw err;
-      }
-    }
-  }
-
   isContextIdentifier(node: t.Identifier): boolean {
     return this.#contextIdentifiers.has(node);
   }

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

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

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

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

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

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

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

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

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

@@ -13,7 +13,11 @@ import {
   pruneUnusedLabels,
   renameVariables,
 } from '.';
-import {CompilerError, ErrorCategory} from '../CompilerError';
+import {
+  CompilerError,
+  CompilerErrorDetail,
+  ErrorCategory,
+} from '../CompilerError';
 import {Environment, ExternalFunction} from '../HIR';
 import {
   ArrayPattern,
@@ -347,10 +351,6 @@ function codegenReactiveFunction(
     }
   }
 
-  if (cx.errors.hasAnyErrors()) {
-    fn.env.recordErrors(cx.errors);
-  }
-
   const countMemoBlockVisitor = new CountMemoBlockVisitor(fn.env);
   visitReactiveFunction(fn, countMemoBlockVisitor, undefined);
 
@@ -420,7 +420,6 @@ class Context {
    */
   #declarations: Set<DeclarationId> = new Set();
   temp: Temporaries;
-  errors: CompilerError = new CompilerError();
   objectMethods: Map<IdentifierId, ObjectMethod> = new Map();
   uniqueIdentifiers: Set<string>;
   fbtOperands: Set<IdentifierId>;
@@ -439,6 +438,11 @@ class Context {
     this.fbtOperands = fbtOperands;
     this.temp = temporaries !== null ? new Map(temporaries) : new Map();
   }
+
+  recordError(error: CompilerErrorDetail): void {
+    this.env.recordError(error);
+  }
+
   get nextCacheIndex(): number {
     return this.#nextCacheIndex++;
   }
@@ -775,12 +779,15 @@ function codegenTerminal(
         loc: terminal.init.loc,
       });
       if (terminal.init.instructions.length !== 2) {
-        CompilerError.throwTodo({
-          reason: 'Support non-trivial for..in inits',
-          description: null,
-          loc: terminal.init.loc,
-          suggestions: null,
-        });
+        cx.recordError(
+          new CompilerErrorDetail({
+            reason: 'Support non-trivial for..in inits',
+            category: ErrorCategory.Todo,
+            loc: terminal.init.loc,
+            suggestions: null,
+          }),
+        );
+        return t.emptyStatement();
       }
       const iterableCollection = terminal.init.instructions[0];
       const iterableItem = terminal.init.instructions[1];
@@ -795,12 +802,15 @@ function codegenTerminal(
           break;
         }
         case 'StoreContext': {
-          CompilerError.throwTodo({
-            reason: 'Support non-trivial for..in inits',
-            description: null,
-            loc: terminal.init.loc,
-            suggestions: null,
-          });
+          cx.recordError(
+            new CompilerErrorDetail({
+              reason: 'Support non-trivial for..in inits',
+              category: ErrorCategory.Todo,
+              loc: terminal.init.loc,
+              suggestions: null,
+            }),
+          );
+          return t.emptyStatement();
         }
         default:
           CompilerError.invariant(false, {
@@ -870,12 +880,15 @@ function codegenTerminal(
         loc: terminal.test.loc,
       });
       if (terminal.test.instructions.length !== 2) {
-        CompilerError.throwTodo({
-          reason: 'Support non-trivial for..of inits',
-          description: null,
-          loc: terminal.init.loc,
-          suggestions: null,
-        });
+        cx.recordError(
+          new CompilerErrorDetail({
+            reason: 'Support non-trivial for..of inits',
+            category: ErrorCategory.Todo,
+            loc: terminal.init.loc,
+            suggestions: null,
+          }),
+        );
+        return t.emptyStatement();
       }
       const iterableItem = terminal.test.instructions[1];
       let lval: t.LVal;
@@ -889,12 +902,15 @@ function codegenTerminal(
           break;
         }
         case 'StoreContext': {
-          CompilerError.throwTodo({
-            reason: 'Support non-trivial for..of inits',
-            description: null,
-            loc: terminal.init.loc,
-            suggestions: null,
-          });
+          cx.recordError(
+            new CompilerErrorDetail({
+              reason: 'Support non-trivial for..of inits',
+              category: ErrorCategory.Todo,
+              loc: terminal.init.loc,
+              suggestions: null,
+            }),
+          );
+          return t.emptyStatement();
         }
         default:
           CompilerError.invariant(false, {
@@ -1953,22 +1969,26 @@ function codegenInstructionValue(
         } else {
           if (t.isVariableDeclaration(stmt)) {
             const declarator = stmt.declarations[0];
-            cx.errors.push({
-              reason: `(CodegenReactiveFunction::codegenInstructionValue) Cannot declare variables in a value block, tried to declare '${
-                (declarator.id as t.Identifier).name
-              }'`,
-              category: ErrorCategory.Todo,
-              loc: declarator.loc ?? null,
-              suggestions: null,
-            });
+            cx.recordError(
+              new CompilerErrorDetail({
+                reason: `(CodegenReactiveFunction::codegenInstructionValue) Cannot declare variables in a value block, tried to declare '${
+                  (declarator.id as t.Identifier).name
+                }'`,
+                category: ErrorCategory.Todo,
+                loc: declarator.loc ?? null,
+                suggestions: null,
+              }),
+            );
             return t.stringLiteral(`TODO handle ${declarator.id}`);
           } else {
-            cx.errors.push({
-              reason: `(CodegenReactiveFunction::codegenInstructionValue) Handle conversion of ${stmt.type} to expression`,
-              category: ErrorCategory.Todo,
-              loc: stmt.loc ?? null,
-              suggestions: null,
-            });
+            cx.recordError(
+              new CompilerErrorDetail({
+                reason: `(CodegenReactiveFunction::codegenInstructionValue) Handle conversion of ${stmt.type} to expression`,
+                category: ErrorCategory.Todo,
+                loc: stmt.loc ?? null,
+                suggestions: null,
+              }),
+            );
             return t.stringLiteral(`TODO handle ${stmt.type}`);
           }
         }

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -124,8 +124,8 @@ export function validateNoRefAccessInRender(fn: HIRFunction): void {
   collectTemporariesSidemap(fn, env);
   const errors = new CompilerError();
   validateNoRefAccessInRenderImpl(fn, env, errors);
-  if (errors.hasAnyErrors()) {
-    fn.env.recordErrors(errors);
+  for (const detail of errors.details) {
+    fn.env.recordError(detail);
   }
 }
 

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

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

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

@@ -27,6 +27,7 @@ import {
   ScopeId,
   SourceLocation,
 } from '../HIR';
+import {Environment} from '../HIR/Environment';
 import {printIdentifier, printManualMemoDependency} from '../HIR/PrintHIR';
 import {
   eachInstructionValueLValue,
@@ -48,13 +49,10 @@ import {getOrInsertDefault} from '../Utils/utils';
  */
 export function validatePreservedManualMemoization(fn: ReactiveFunction): void {
   const state = {
-    errors: new CompilerError(),
+    env: fn.env,
     manualMemoState: null,
   };
   visitReactiveFunction(fn, new Visitor(), state);
-  for (const detail of state.errors.details) {
-    fn.env.recordError(detail);
-  }
 }
 
 const DEBUG = false;
@@ -112,7 +110,7 @@ type ManualMemoBlockState = {
 };
 
 type VisitorState = {
-  errors: CompilerError;
+  env: Environment;
   manualMemoState: ManualMemoBlockState | null;
 };
 
@@ -232,7 +230,7 @@ function validateInferredDep(
   temporaries: Map<IdentifierId, ManualMemoDependency>,
   declsWithinMemoBlock: Set<DeclarationId>,
   validDepsInMemoBlock: Array<ManualMemoDependency>,
-  errorState: CompilerError,
+  env: Environment,
   memoLocation: SourceLocation,
 ): void {
   let normalizedDep: ManualMemoDependency;
@@ -282,7 +280,7 @@ function validateInferredDep(
       errorDiagnostic = merge(errorDiagnostic ?? compareResult, compareResult);
     }
   }
-  errorState.pushDiagnostic(
+  env.recordError(
     CompilerDiagnostic.create({
       category: ErrorCategory.PreserveManualMemo,
       reason: 'Existing memoization could not be preserved',
@@ -428,7 +426,7 @@ class Visitor extends ReactiveFunctionVisitor<VisitorState> {
           this.temporaries,
           state.manualMemoState.decls,
           state.manualMemoState.depsFromSource,
-          state.errors,
+          state.env,
           state.manualMemoState.loc,
         );
       }
@@ -531,7 +529,7 @@ class Visitor extends ReactiveFunctionVisitor<VisitorState> {
           !this.scopes.has(identifier.scope.id) &&
           !this.prunedScopes.has(identifier.scope.id)
         ) {
-          state.errors.pushDiagnostic(
+          state.env.recordError(
             CompilerDiagnostic.create({
               category: ErrorCategory.PreserveManualMemo,
               reason: 'Existing memoization could not be preserved',
@@ -577,7 +575,7 @@ class Visitor extends ReactiveFunctionVisitor<VisitorState> {
 
           for (const identifier of decls) {
             if (isUnmemoized(identifier, this.scopes)) {
-              state.errors.pushDiagnostic(
+              state.env.recordError(
                 CompilerDiagnostic.create({
                   category: ErrorCategory.PreserveManualMemo,
                   reason: 'Existing memoization could not be preserved',

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

@@ -7,7 +7,7 @@
 
 import {NodePath} from '@babel/traverse';
 import * as t from '@babel/types';
-import {CompilerDiagnostic, CompilerError, ErrorCategory} from '..';
+import {CompilerDiagnostic, ErrorCategory} from '..';
 import {CodegenFunction} from '../ReactiveScopes';
 import {Environment} from '../HIR/Environment';
 
@@ -125,8 +125,6 @@ export function validateSourceLocations(
   generatedAst: CodegenFunction,
   env: Environment,
 ): void {
-  const errors = new CompilerError();
-
   /*
    * Step 1: Collect important locations from the original source
    * Note: Multiple node types can share the same location (e.g. VariableDeclarator and Identifier)
@@ -241,7 +239,7 @@ export function validateSourceLocations(
     loc: t.SourceLocation,
     nodeType: string,
   ): void => {
-    errors.pushDiagnostic(
+    env.recordError(
       CompilerDiagnostic.create({
         category: ErrorCategory.Todo,
         reason: 'Important source location missing in generated code',
@@ -261,7 +259,7 @@ export function validateSourceLocations(
     expectedType: string,
     actualTypes: Set<string>,
   ): void => {
-    errors.pushDiagnostic(
+    env.recordError(
       CompilerDiagnostic.create({
         category: ErrorCategory.Todo,
         reason:
@@ -309,8 +307,4 @@ export function validateSourceLocations(
       }
     }
   }
-
-  for (const detail of errors.details) {
-    env.recordError(detail);
-  }
 }

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

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

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

@@ -24,9 +24,9 @@ function useThing(fn) {
 ```
 Found 1 error:
 
-Invariant: [HIRBuilder] Unexpected null block
+Error: Expected a non-reserved identifier name
 
-expected block 0 to exist.
+`this` is a reserved word in JavaScript and cannot be used as an identifier name.
 ```
           
       

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.todo-optional-call-chain-in-optional.expect.md

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

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

@@ -18,7 +18,12 @@ function Component() {
   // Error: reading ref during render
   const value = ref.current;
 
-  return <div>{value}{items.length}</div>;
+  return (
+    <div>
+      {value}
+      {items.length}
+    </div>
+  );
 }
 
 ```
@@ -50,8 +55,8 @@ error.var-declaration-and-ref-access.ts:15:16
 > 15 |   const value = ref.current;
      |                 ^^^^^^^^^^^ Cannot access ref value during render
   16 |
-  17 |   return <div>{value}{items.length}</div>;
-  18 | }
+  17 |   return (
+  18 |     <div>
 ```
           
       

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

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

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

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

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

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

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

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

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

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

compiler/packages/snap/src/compiler.ts

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