[compiler] Handle more cases with for in try/catch

Author: josephsavona

…aude/agents/compiler-bug-investigator.md …iler/.claude/agents/investigate-error.mdcompiler/.claude/agents/compiler-bug-investigator.md renamed to compiler/.claude/agents/investigate-error.md compiler/.claude/agents/compiler-bug-investigator.md renamed to compiler/.claude/agents/investigate-error.md

@@ -1,6 +1,6 @@
 ---
-name: compiler-bug-investigator
-description: "Use this agent when the developer asks to 'investigate a bug', 'debug why this fixture errors', 'understand why the compiler is failing', 'find the root cause of a compiler issue', or when they provide a code snippet that the React Compiler handles incorrectly and want to understand why. This agent is specifically for React Compiler bugs, not general React bugs.\\n\\n<example>\\nContext: User provides a code snippet that causes the compiler to error unexpectedly.\\nuser: \"Can you investigate why this code errors? function Component() { const x = a?.b; return <div>{x}</div> }\"\\nassistant: \"I'll use the compiler-bug-investigator agent to investigate this bug and find the root cause.\"\\n<Task tool call to launch compiler-bug-investigator>\\n</example>\\n\\n<example>\\nContext: User asks to debug a fixture that's producing incorrect output.\\nuser: \"Debug why the fixture error.invalid-optional-chain.js is failing\"\\nassistant: \"Let me launch the compiler-bug-investigator agent to analyze this fixture and identify the problematic compiler pass.\"\\n<Task tool call to launch compiler-bug-investigator>\\n</example>\\n\\n<example>\\nContext: User wants to understand unexpected compiler behavior.\\nuser: \"Investigate a bug - the compiler is generating wrong code for ternary expressions with side effects\"\\nassistant: \"I'll use the compiler-bug-investigator agent to systematically investigate this issue and identify the faulty compiler logic.\"\\n<Task tool call to launch compiler-bug-investigator>\\n</example>"
+name: investigate-error
+description: Investigates React compiler errors to determine the root cause and identify potential mitigation(s). Use this agent when the user asks to 'investigate a bug', 'debug why this fixture errors', 'understand why the compiler is failing', 'find the root cause of a compiler issue', or when they provide a snippet of code and ask to debug. Use automatically when encountering a failing test case, in order to understand the root cause.
 model: opus
 color: pink
 ---

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

@@ -612,7 +612,7 @@ export type TryTerminal = {
 export type MaybeThrowTerminal = {
   kind: 'maybe-throw';
   continuation: BlockId;
-  handler: BlockId;
+  handler: BlockId | null;
   id: InstructionId;
   loc: SourceLocation;
   fallthrough?: never;

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

@@ -291,7 +291,9 @@ export function printTerminal(terminal: Terminal): Array<string> | string {
       break;
     }
     case 'maybe-throw': {
-      value = `[${terminal.id}] MaybeThrow continuation=bb${terminal.continuation} handler=bb${terminal.handler}`;
+      const handlerStr =
+        terminal.handler !== null ? `bb${terminal.handler}` : '(none)';
+      value = `[${terminal.id}] MaybeThrow continuation=bb${terminal.continuation} handler=${handlerStr}`;
       if (terminal.effects != null) {
         value += `\n    ${terminal.effects.map(printAliasingEffect).join('\n    ')}`;
       }

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

@@ -909,7 +909,8 @@ export function mapTerminalSuccessors(
     }
     case 'maybe-throw': {
       const continuation = fn(terminal.continuation);
-      const handler = fn(terminal.handler);
+      const handler =
+        terminal.handler !== null ? fn(terminal.handler) : null;
       return {
         kind: 'maybe-throw',
         continuation,
@@ -1083,7 +1084,9 @@ export function* eachTerminalSuccessor(terminal: Terminal): Iterable<BlockId> {
     }
     case 'maybe-throw': {
       yield terminal.continuation;
-      yield terminal.handler;
+      if (terminal.handler !== null) {
+        yield terminal.handler;
+      }
       break;
     }
     case 'try': {

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

@@ -508,7 +508,7 @@ function inferBlock(
   const terminal = block.terminal;
   if (terminal.kind === 'try' && terminal.handlerBinding != null) {
     context.catchHandlers.set(terminal.handler, terminal.handlerBinding);
-  } else if (terminal.kind === 'maybe-throw') {
+  } else if (terminal.kind === 'maybe-throw' && terminal.handler !== null) {
     const handlerParam = context.catchHandlers.get(terminal.handler);
     if (handlerParam != null) {
       CompilerError.invariant(state.kind(handlerParam) != null, {

compiler/packages/babel-plugin-react-compiler/src/Optimization/PruneMaybeThrows.ts

@@ -9,7 +9,6 @@ import {CompilerError} from '..';
 import {
   BlockId,
   GeneratedSource,
-  GotoVariant,
   HIRFunction,
   Instruction,
   assertConsistentIdentifiers,
@@ -25,9 +24,15 @@ import {
 } from '../HIR/HIRBuilder';
 import {printPlace} from '../HIR/PrintHIR';
 
-/*
- * This pass prunes `maybe-throw` terminals for blocks that can provably *never* throw.
- * For now this is very conservative, and only affects blocks with primitives or
+/**
+ * This pass updates `maybe-throw` terminals for blocks that can provably *never* throw,
+ * nulling out the handler to indicate that control will always continue. Note that
+ * rewriting to a `goto` disrupts the structure of the HIR, making it more difficult to
+ * reconstruct an ast during BuildReactiveFunction. Preserving the maybe-throw makes the
+ * continuations clear, while nulling out the handler tells us that control cannot flow
+ * to the handler.
+ *
+ * For now the analysis is very conservative, and only affects blocks with primitives or
  * array/object literals. Even a variable reference could throw bc of the TDZ.
  */
 export function pruneMaybeThrows(fn: HIRFunction): void {
@@ -82,13 +87,7 @@ function pruneMaybeThrowsImpl(fn: HIRFunction): Map<BlockId, BlockId> | null {
     if (!canThrow) {
       const source = terminalMapping.get(block.id) ?? block.id;
       terminalMapping.set(terminal.continuation, source);
-      block.terminal = {
-        kind: 'goto',
-        block: terminal.continuation,
-        variant: GotoVariant.Break,
-        id: terminal.id,
-        loc: terminal.loc,
-      };
+      terminal.handler = null;
     }
   }
   return terminalMapping.size > 0 ? terminalMapping : null;

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

@@ -168,10 +168,12 @@ class Driver {
       innerValue = innerValue.value;
     }
 
-    // Only add the final instruction if the innermost value is not just a LoadLocal
-    // of the same place we're storing to (which would be a no-op).
-    // This happens when MaybeThrow blocks cause the sequence to already contain
-    // all the necessary instructions.
+    /*
+     * Only add the final instruction if the innermost value is not just a LoadLocal
+     * of the same place we're storing to (which would be a no-op).
+     * This happens when MaybeThrow blocks cause the sequence to already contain
+     * all the necessary instructions.
+     */
     const isLoadOfSamePlace =
       innerValue.kind === 'LoadLocal' &&
       innerValue.place.identifier.id === result.place.identifier.id;
@@ -496,7 +498,10 @@ class Driver {
         const init = this.visitValueBlock(terminal.init, terminal.loc);
         const initValue = this.valueBlockResultToSequence(init, terminal.loc);
 
-        const testValue = this.visitValueBlock(terminal.test, terminal.loc).value;
+        const testValue = this.visitValueBlock(
+          terminal.test,
+          terminal.loc,
+        ).value;
 
         const updateValue =
           terminal.update !== null