[compiler] Remove tryRecord, add catch-all error handling, fix remaining throws (#35881)

Remove `tryRecord()` from the compilation pipeline now that all passes record errors directly via `env.recordError()` / `env.recordErrors()`. A single catch-all try/catch in Program.ts provides the safety net for any pass that incorrectly throws instead of recording. Key changes: - Remove all ~64 `env.tryRecord()` wrappers in Pipeline.ts - Delete `tryRecord()` method from Environment.ts - Add `CompileUnexpectedThrow` logger event so thrown errors are detectable - Log `CompileUnexpectedThrow` in Program.ts catch-all for non-invariant throws - Fail snap tests on `CompileUnexpectedThrow` to surface pass bugs in dev - Convert throwTodo/throwDiagnostic calls in HIRBuilder (fbt, this), CodegenReactiveFunction (for-in/for-of), and BuildReactiveFunction to record errors or use invariants as appropriate - Remove try/catch from BuildHIR's lower() since inner throws are now recorded - CollectOptionalChainDependencies: return null instead of throwing on unsupported optional chain patterns (graceful optimization skip) --- [//]: # (BEGIN SAPLING FOOTER) Stack created with [Sapling](https://sapling-scm.com). Best reviewed with [ReviewStack](https://reviewstack.dev/facebook/react/pull/35881). * #35888 * #35884 * #35883 * #35882 * __->__ #35881
2026-02-26 07:25:30 +00:00 · 2026-02-23 16:10:17 -08:00
parent 8a33fb3a1c
commit 9075330979
19 changed files with 260 additions and 243 deletions
--- a/compiler/packages/babel-plugin-react-compiler/src/Entrypoint/Options.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/Entrypoint/Options.ts
@@ -252,6 +252,7 @@ export type LoggerEvent =
  | CompileErrorEvent
  | CompileDiagnosticEvent
  | CompileSkipEvent
+  | CompileUnexpectedThrowEvent
  | PipelineErrorEvent
  | TimingEvent;

@@ -286,6 +287,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;
--- a/compiler/packages/babel-plugin-react-compiler/src/Entrypoint/Pipeline.ts
+++ b/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,
@@ -161,12 +160,8 @@ function runWithEnvironment(
  pruneMaybeThrows(hir);
  log({kind: 'hir', name: 'PruneMaybeThrows', value: hir});

-  env.tryRecord(() => {
-    validateContextVariableLValues(hir);
-  });
-  env.tryRecord(() => {
-    validateUseMemo(hir);
-  });
+  validateContextVariableLValues(hir);
+  validateUseMemo(hir);

  if (env.enableDropManualMemoization) {
    dropManualMemoization(hir);
@@ -202,14 +197,10 @@ function runWithEnvironment(

  if (env.enableValidations) {
    if (env.config.validateHooksUsage) {
-      env.tryRecord(() => {
-        validateHooksUsage(hir);
-      });
+      validateHooksUsage(hir);
    }
    if (env.config.validateNoCapitalizedCalls) {
-      env.tryRecord(() => {
-        validateNoCapitalizedCalls(hir);
-      });
+      validateNoCapitalizedCalls(hir);
    }
  }

@@ -219,9 +210,7 @@ function runWithEnvironment(
  analyseFunctions(hir);
  log({kind: 'hir', name: 'AnalyseFunctions', value: hir});

-  env.tryRecord(() => {
-    inferMutationAliasingEffects(hir);
-  });
+  inferMutationAliasingEffects(hir);
  log({kind: 'hir', name: 'InferMutationAliasingEffects', value: hir});

  if (env.outputMode === 'ssr') {
@@ -235,31 +224,23 @@ function runWithEnvironment(
  pruneMaybeThrows(hir);
  log({kind: 'hir', name: 'PruneMaybeThrows', value: hir});

-  env.tryRecord(() => {
-    inferMutationAliasingRanges(hir, {
-      isFunctionExpression: false,
-    });
+  inferMutationAliasingRanges(hir, {
+    isFunctionExpression: false,
  });
  log({kind: 'hir', name: 'InferMutationAliasingRanges', value: hir});
  if (env.enableValidations) {
-    env.tryRecord(() => {
-      validateLocalsNotReassignedAfterRender(hir);
-    });
+    validateLocalsNotReassignedAfterRender(hir);

    if (env.config.assertValidMutableRanges) {
      assertValidMutableRanges(hir);
    }

    if (env.config.validateRefAccessDuringRender) {
-      env.tryRecord(() => {
-        validateNoRefAccessInRender(hir);
-      });
+      validateNoRefAccessInRender(hir);
    }

    if (env.config.validateNoSetStateInRender) {
-      env.tryRecord(() => {
-        validateNoSetStateInRender(hir);
-      });
+      validateNoSetStateInRender(hir);
    }

    if (
@@ -268,9 +249,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') {
@@ -281,9 +260,7 @@ function runWithEnvironment(
      env.logErrors(validateNoJSXInTryStatement(hir));
    }

-    env.tryRecord(() => {
-      validateNoFreezingKnownMutableFunctions(hir);
-    });
+    validateNoFreezingKnownMutableFunctions(hir);
  }

  inferReactivePlaces(hir);
@@ -295,9 +272,7 @@ function runWithEnvironment(
      env.config.validateExhaustiveEffectDependencies
    ) {
      // NOTE: this relies on reactivity inference running first
-      env.tryRecord(() => {
-        validateExhaustiveDependencies(hir);
-      });
+      validateExhaustiveDependencies(hir);
    }
  }

@@ -326,8 +301,7 @@ function runWithEnvironment(
    log({kind: 'hir', name: 'InferReactiveScopeVariables', value: hir});
  }

-  let fbtOperands: Set<IdentifierId> = new Set();
-  fbtOperands = memoizeFbtAndMacroOperandsInSameScope(hir);
+  const fbtOperands = memoizeFbtAndMacroOperandsInSameScope(hir);
  log({
    kind: 'hir',
    name: 'MemoizeFbtAndMacroOperandsInSameScope',
@@ -412,6 +386,7 @@ function runWithEnvironment(
  });
  assertTerminalSuccessorsExist(hir);
  assertTerminalPredsExist(hir);
+
  propagateScopeDependenciesHIR(hir);
  log({
    kind: 'hir',
@@ -419,8 +394,7 @@ function runWithEnvironment(
    value: hir,
  });

-  let reactiveFunction!: ReactiveFunction;
-  reactiveFunction = buildReactiveFunction(hir);
+  const reactiveFunction = buildReactiveFunction(hir);
  log({
    kind: 'reactive',
    name: 'BuildReactiveFunction',
@@ -507,8 +481,7 @@ function runWithEnvironment(
    value: reactiveFunction,
  });

-  let uniqueIdentifiers: Set<string> = new Set();
-  uniqueIdentifiers = renameVariables(reactiveFunction);
+  const uniqueIdentifiers = renameVariables(reactiveFunction);
  log({
    kind: 'reactive',
    name: 'RenameVariables',
@@ -526,9 +499,7 @@ function runWithEnvironment(
    env.config.enablePreserveExistingMemoizationGuarantees ||
    env.config.validatePreserveExistingMemoizationGuarantees
  ) {
-    env.tryRecord(() => {
-      validatePreservedManualMemoization(reactiveFunction);
-    });
+    validatePreservedManualMemoization(reactiveFunction);
  }

  const ast = codegenFunction(reactiveFunction, {
@@ -541,9 +512,7 @@ function runWithEnvironment(
  }

  if (env.config.validateSourceLocations) {
-    env.tryRecord(() => {
-      validateSourceLocations(func, ast, env);
-    });
+    validateSourceLocations(func, ast, env);
  }

  /**
--- a/compiler/packages/babel-plugin-react-compiler/src/Entrypoint/Program.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/Entrypoint/Program.ts
@@ -713,6 +713,20 @@ 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};
  }
 }
--- a/compiler/packages/babel-plugin-react-compiler/src/HIR/BuildHIR.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/HIR/BuildHIR.ts
@@ -185,47 +185,32 @@ export function lower(

  let directives: Array<string> = [];
  const body = func.get('body');
-  try {
-    if (body.isExpression()) {
-      const fallthrough = builder.reserve('block');
-      const terminal: ReturnTerminal = {
-        kind: 'return',
-        returnVariant: 'Implicit',
-        loc: GeneratedSource,
-        value: lowerExpressionToTemporary(builder, body),
-        id: makeInstructionId(0),
-        effects: null,
-      };
-      builder.terminateWithContinuation(terminal, fallthrough);
-    } else if (body.isBlockStatement()) {
-      lowerStatement(builder, body);
-      directives = body.get('directives').map(d => d.node.value.value);
-    } else {
-      builder.errors.pushDiagnostic(
-        CompilerDiagnostic.create({
-          category: ErrorCategory.Syntax,
-          reason: `Unexpected function body kind`,
-          description: `Expected function body to be an expression or a block statement, got \`${body.type}\``,
-        }).withDetails({
-          kind: 'error',
-          loc: body.node.loc ?? null,
-          message: 'Expected a block statement or expression',
-        }),
-      );
-    }
-  } catch (err) {
-    if (err instanceof CompilerError) {
-      // Re-throw invariant errors immediately
-      for (const detail of err.details) {
-        if (detail.category === ErrorCategory.Invariant) {
-          throw err;
-        }
-      }
-      // Record non-invariant errors and continue to produce partial HIR
-      builder.errors.merge(err);
-    } else {
-      throw err;
-    }
+  if (body.isExpression()) {
+    const fallthrough = builder.reserve('block');
+    const terminal: ReturnTerminal = {
+      kind: 'return',
+      returnVariant: 'Implicit',
+      loc: GeneratedSource,
+      value: lowerExpressionToTemporary(builder, body),
+      id: makeInstructionId(0),
+      effects: null,
+    };
+    builder.terminateWithContinuation(terminal, fallthrough);
+  } else if (body.isBlockStatement()) {
+    lowerStatement(builder, body);
+    directives = body.get('directives').map(d => d.node.value.value);
+  } else {
+    builder.errors.pushDiagnostic(
+      CompilerDiagnostic.create({
+        category: ErrorCategory.Syntax,
+        reason: `Unexpected function body kind`,
+        description: `Expected function body to be an expression or a block statement, got \`${body.type}\``,
+      }).withDetails({
+        kind: 'error',
+        loc: body.node.loc ?? null,
+        message: 'Expected a block statement or expression',
+      }),
+    );
  }

  let validatedId: HIRFunction['id'] = null;
--- a/compiler/packages/babel-plugin-react-compiler/src/HIR/CollectOptionalChainDependencies.ts
+++ b/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
--- a/compiler/packages/babel-plugin-react-compiler/src/HIR/Environment.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/HIR/Environment.ts
@@ -759,29 +759,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);
  }
--- a/compiler/packages/babel-plugin-react-compiler/src/HIR/HIRBuilder.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/HIR/HIRBuilder.ts
@@ -308,33 +308,23 @@ export default class HIRBuilder {

  resolveBinding(node: t.Identifier): Identifier {
    if (node.name === 'fbt') {
-      CompilerError.throwDiagnostic({
+      this.errors.push({
        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,
-          },
-        ],
+        loc: node.loc ?? GeneratedSource,
+        suggestions: null,
      });
    }
    if (node.name === 'this') {
-      CompilerError.throwDiagnostic({
+      this.errors.push({
        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,
-          },
-        ],
+        loc: node.loc ?? GeneratedSource,
+        suggestions: null,
      });
    }
    const originalName = node.name;
--- a/compiler/packages/babel-plugin-react-compiler/src/ReactiveScopes/BuildReactiveFunction.ts
+++ b/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 {
--- a/compiler/packages/babel-plugin-react-compiler/src/ReactiveScopes/CodegenReactiveFunction.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/ReactiveScopes/CodegenReactiveFunction.ts
@@ -775,12 +775,13 @@ function codegenTerminal(
        loc: terminal.init.loc,
      });
      if (terminal.init.instructions.length !== 2) {
-        CompilerError.throwTodo({
+        cx.errors.push({
          reason: 'Support non-trivial for..in inits',
-          description: null,
+          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 +796,13 @@ function codegenTerminal(
          break;
        }
        case 'StoreContext': {
-          CompilerError.throwTodo({
+          cx.errors.push({
            reason: 'Support non-trivial for..in inits',
-            description: null,
+            category: ErrorCategory.Todo,
            loc: terminal.init.loc,
            suggestions: null,
          });
+          return t.emptyStatement();
        }
        default:
          CompilerError.invariant(false, {
@@ -870,12 +872,13 @@ function codegenTerminal(
        loc: terminal.test.loc,
      });
      if (terminal.test.instructions.length !== 2) {
-        CompilerError.throwTodo({
+        cx.errors.push({
          reason: 'Support non-trivial for..of inits',
-          description: null,
+          category: ErrorCategory.Todo,
          loc: terminal.init.loc,
          suggestions: null,
        });
+        return t.emptyStatement();
      }
      const iterableItem = terminal.test.instructions[1];
      let lval: t.LVal;
@@ -889,12 +892,13 @@ function codegenTerminal(
          break;
        }
        case 'StoreContext': {
-          CompilerError.throwTodo({
+          cx.errors.push({
            reason: 'Support non-trivial for..of inits',
-            description: null,
+            category: ErrorCategory.Todo,
            loc: terminal.init.loc,
            suggestions: null,
          });
+          return t.emptyStatement();
        }
        default:
          CompilerError.invariant(false, {
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/ecma/error.reserved-words.expect.md
+++ b/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.
 ```
          
      
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/error.todo-optional-call-chain-in-optional.expect.md
+++ b/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> {
-```
-          
-      
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/fbt/error.todo-fbt-as-local.expect.md
+++ b/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'
 ```
          
      
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/fbt/error.todo-locally-require-fbt.expect.md
+++ b/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 |
 ```
          
      
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/propagate-scope-deps-hir-fork/error.todo-optional-call-chain-in-optional.expect.md
+++ b/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> {
-```
-          
-      
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/propagate-scope-deps-hir-fork/todo-optional-call-chain-in-optional.expect.md
+++ b/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
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/propagate-scope-deps-hir-fork/error.todo-optional-call-chain-in-optional.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/propagate-scope-deps-hir-fork/error.todo-optional-call-chain-in-optional.ts
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/todo-optional-call-chain-in-optional.expect.md
+++ b/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
--- a/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/error.todo-optional-call-chain-in-optional.ts
+++ b/compiler/packages/babel-plugin-react-compiler/src/tests/fixtures/compiler/error.todo-optional-call-chain-in-optional.ts
--- a/compiler/packages/snap/src/compiler.ts
+++ b/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: {