fix: prevent catch parameter aliases from breaking scope boundaries in noBackwardRangeExtension heuristic

Track catch handler bindings in AliasingState so the backward-alias
walk in mutate() stops at catch parameters. Without this, catch
parameters aliased to call results in try blocks incorrectly trigger
the effectiveSkipAliases heuristic, preventing backward range
extension and causing 'Expected a break target' crashes when try-catch
blocks get split across reactive scopes.

Fixes 4 compiler crashes (try-catch-try-value-modified-in-catch and
variants) and 1 snapshot regression (try-catch-alias-try-values).
Updates 8 snapshot expectations for tests where the noBackwardRangeExtension
change produces different but functionally correct memoization output.

Closes #35902

Author: fresh3nough

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

@@ -231,6 +231,9 @@ export function inferMutationAliasingRanges(
       for (const effect of block.terminal.effects) {
         if (effect.kind === 'Alias') {
           state.assign(index++, effect.from, effect.into);
+          if (block.terminal.kind === 'maybe-throw') {
+            state.catchParams.add(effect.into.identifier);
+          }
         } else {
           CompilerError.invariant(effect.kind === 'Freeze', {
             reason: `Unexpected '${effect.kind}' effect for MaybeThrow terminal`,
@@ -600,6 +603,13 @@ type Node = {
 };
 class AliasingState {
   nodes: Map<Identifier, Node> = new Map();
+  /*
+   * Identifiers that are catch handler bindings. These are tracked
+   * so the backward-alias heuristic in mutate() can stop walking
+   * through catch parameter aliases, which would otherwise incorrectly
+   * match the "function call result" pattern and skip range extension.
+   */
+  catchParams: Set<Identifier> = new Set();
 
   create(place: Place, value: Node['value']): void {
     this.nodes.set(place.identifier, {
@@ -740,8 +750,10 @@ class AliasingState {
        * Apply results are identifiable by having maybeAliases, since the
        * default Apply handler records MaybeAlias from each argument to
        * the result. Only walk through alias edges (not maybeAliases or
-       * captures) to avoid matching catch parameters and similar patterns
-       * where range extension is required for correctness.
+       * captures). Additionally, stop walking when a catch parameter is
+       * reached, since catch parameters are aliased to call results via
+       * terminal Alias effects and would otherwise incorrectly trigger
+       * this heuristic.
        */
       const visited = new Set<Identifier>();
       const aliasQueue: Array<Identifier> = [start];
@@ -755,6 +767,18 @@ class AliasingState {
         if (node == null) {
           continue;
         }
+        /*
+         * Stop walking through catch parameter aliases. Catch bindings
+         * are aliased to call results in the try block, and those call
+         * results have maybeAliases from the Apply handler. Without
+         * this check, the heuristic would incorrectly treat catch
+         * parameters as independently-memoizable function call results,
+         * preventing backward range extension and causing scope boundary
+         * issues (e.g. "Expected a break target" in try-catch blocks).
+         */
+        if (this.catchParams.has(id)) {
+          continue;
+        }
         if (node.maybeAliases.size > 0) {
           effectiveSkipAliases = true;
           break;

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/align-scopes-within-nested-valueblock-in-array.expect.md

@@ -51,9 +51,9 @@ import { Stringify, identity, makeArray, mutate } from "shared-runtime";
 function Foo(t0) {
   const $ = _c(3);
   const { cond1, cond2 } = t0;
+  const arr = makeArray({ a: 2 }, 2, []);
   let t1;
   if ($[0] !== cond1 || $[1] !== cond2) {
-    const arr = makeArray({ a: 2 }, 2, []);
     t1 = cond1 ? (
       <>
         <div>{identity("foo")}</div>

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/global-types/set-add-mutate.expect.md

@@ -33,24 +33,32 @@ import { c as _c } from "react/compiler-runtime";
 import { makeArray } from "shared-runtime";
 
 function useHook(t0) {
-  const $ = _c(5);
+  const $ = _c(7);
   const { el1, el2 } = t0;
   let s;
   if ($[0] !== el1 || $[1] !== el2) {
     s = new Set();
-    const arr = makeArray(el1);
-    s.add(arr);
-
-    arr.push(el2);
     let t1;
-    if ($[3] !== el2) {
-      t1 = makeArray(el2);
-      $[3] = el2;
+    if ($[3] !== el1) {
+      t1 = makeArray(el1);
+      $[3] = el1;
       $[4] = t1;
     } else {
       t1 = $[4];
     }
-    s.add(t1);
+    const arr = t1;
+    s.add(arr);
+
+    arr.push(el2);
+    let t2;
+    if ($[5] !== el2) {
+      t2 = makeArray(el2);
+      $[5] = el2;
+      $[6] = t2;
+    } else {
+      t2 = $[6];
+    }
+    s.add(t2);
     $[0] = el1;
     $[1] = el2;
     $[2] = s;

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/hooks-with-prefix.expect.md

@@ -46,7 +46,7 @@ const React$useMemo = React.useMemo;
 const Internal$Reassigned$useHook = useHook;
 
 function Component() {
-  const $ = _c(7);
+  const $ = _c(9);
   const [state] = React$useState(0);
   const object = Internal$Reassigned$useHook();
   let t0;
@@ -60,28 +60,36 @@ function Component() {
   const json = t0;
   let t1;
   if ($[2] !== state) {
-    const doubledArray = makeArray(state);
-    t1 = doubledArray.join("");
+    t1 = makeArray(state);
     $[2] = state;
     $[3] = t1;
   } else {
     t1 = $[3];
   }
+  const doubledArray = t1;
   let t2;
-  if ($[4] !== json || $[5] !== t1) {
-    t2 = (
+  if ($[4] !== doubledArray) {
+    t2 = doubledArray.join("");
+    $[4] = doubledArray;
+    $[5] = t2;
+  } else {
+    t2 = $[5];
+  }
+  let t3;
+  if ($[6] !== json || $[7] !== t2) {
+    t3 = (
       <div>
-        {t1}
+        {t2}
         {json}
       </div>
     );
-    $[4] = json;
-    $[5] = t1;
-    $[6] = t2;
+    $[6] = json;
+    $[7] = t2;
+    $[8] = t3;
   } else {
-    t2 = $[6];
+    t3 = $[8];
   }
-  return t2;
+  return t3;
 }
 
 export const FIXTURE_ENTRYPOINT = {

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/new-mutability/set-add-mutate.expect.md

@@ -21,24 +21,32 @@ function useHook({el1, el2}) {
 ```javascript
 import { c as _c } from "react/compiler-runtime"; // @enableNewMutationAliasingModel
 function useHook(t0) {
-  const $ = _c(5);
+  const $ = _c(7);
   const { el1, el2 } = t0;
   let s;
   if ($[0] !== el1 || $[1] !== el2) {
     s = new Set();
-    const arr = makeArray(el1);
-    s.add(arr);
-
-    arr.push(el2);
     let t1;
-    if ($[3] !== el2) {
-      t1 = makeArray(el2);
-      $[3] = el2;
+    if ($[3] !== el1) {
+      t1 = makeArray(el1);
+      $[3] = el1;
       $[4] = t1;
     } else {
       t1 = $[4];
     }
-    s.add(t1);
+    const arr = t1;
+    s.add(arr);
+
+    arr.push(el2);
+    let t2;
+    if ($[5] !== el2) {
+      t2 = makeArray(el2);
+      $[5] = el2;
+      $[6] = t2;
+    } else {
+      t2 = $[6];
+    }
+    s.add(t2);
     $[0] = el1;
     $[1] = el2;
     $[2] = s;

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/repro-independently-memoized-property-load-for-method-call.expect.md

@@ -54,40 +54,54 @@ export const FIXTURE_ENTRYPOINT = {
 ```javascript
 import { c as _c } from "react/compiler-runtime";
 function Component(t0) {
-  const $ = _c(8);
+  const $ = _c(12);
   const { label, highlightedItem } = t0;
   const serverTime = useServerTime();
   let t1;
+  if ($[0] !== highlightedItem) {
+    t1 = new Highlight(highlightedItem);
+    $[0] = highlightedItem;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  let t2;
   let timestampLabel;
-  if ($[0] !== highlightedItem || $[1] !== label || $[2] !== serverTime) {
-    const highlight = new Highlight(highlightedItem);
+  if ($[2] !== label || $[3] !== serverTime || $[4] !== t1) {
+    const highlight = t1;
     const time = serverTime.get();
     timestampLabel = time / 1000 || label;
-    t1 = highlight.render();
-    $[0] = highlightedItem;
-    $[1] = label;
-    $[2] = serverTime;
-    $[3] = t1;
-    $[4] = timestampLabel;
+    if ($[7] !== highlight) {
+      t2 = highlight.render();
+      $[7] = highlight;
+      $[8] = t2;
+    } else {
+      t2 = $[8];
+    }
+    $[2] = label;
+    $[3] = serverTime;
+    $[4] = t1;
+    $[5] = t2;
+    $[6] = timestampLabel;
   } else {
-    t1 = $[3];
-    timestampLabel = $[4];
+    t2 = $[5];
+    timestampLabel = $[6];
   }
-  let t2;
-  if ($[5] !== t1 || $[6] !== timestampLabel) {
-    t2 = (
+  let t3;
+  if ($[9] !== t2 || $[10] !== timestampLabel) {
+    t3 = (
       <>
-        {t1}
+        {t2}
         {timestampLabel}
       </>
     );
-    $[5] = t1;
-    $[6] = timestampLabel;
-    $[7] = t2;
+    $[9] = t2;
+    $[10] = timestampLabel;
+    $[11] = t3;
   } else {
-    t2 = $[7];
+    t3 = $[11];
   }
-  return t2;
+  return t3;
 }
 
 function useServerTime() {

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/repro-unmerged-fbt-call-merge-overlapping-reactive-scopes.expect.md

@@ -36,27 +36,35 @@ import fbt from "fbt";
 import { Stringify } from "shared-runtime";
 
 function Component(props) {
-  const $ = _c(3);
+  const $ = _c(5);
   let t0;
-  if ($[0] !== props.cond || $[1] !== props.value.length) {
-    const label = fbt._(
+  if ($[0] !== props.value.length) {
+    t0 = fbt._(
       { "*": "{number} bars", _1: "1 bar" },
       [fbt._plural(props.value.length, "number")],
       { hk: "4mUen7" },
     );
-    t0 = props.cond ? (
+    $[0] = props.value.length;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  const label = t0;
+  let t1;
+  if ($[2] !== label || $[3] !== props.cond) {
+    t1 = props.cond ? (
       <Stringify
         description={fbt._("Text here", null, { hk: "21YpZs" })}
         label={label.toString()}
       />
     ) : null;
-    $[0] = props.cond;
-    $[1] = props.value.length;
-    $[2] = t0;
+    $[2] = label;
+    $[3] = props.cond;
+    $[4] = t1;
   } else {
-    t0 = $[2];
+    t1 = $[4];
   }
-  return t0;
+  return t1;
 }
 
 export const FIXTURE_ENTRYPOINT = {

compiler/packages/babel-plugin-react-compiler/src/__tests__/fixtures/compiler/todo-global-load-cached.expect.md

@@ -35,31 +35,47 @@ import { makeArray } from "shared-runtime";
  * and avoid adding them to `temporariesUsedOutsideDefiningScope`.
  */
 function Component(t0) {
-  const $ = _c(6);
+  const $ = _c(12);
   const { num } = t0;
-  let T0;
   let t1;
   if ($[0] !== num) {
-    const arr = makeArray(num);
-    T0 = Stringify;
-    t1 = arr.push(num);
+    t1 = makeArray(num);
     $[0] = num;
-    $[1] = T0;
-    $[2] = t1;
+    $[1] = t1;
   } else {
-    T0 = $[1];
-    t1 = $[2];
+    t1 = $[1];
   }
+  let T0;
   let t2;
-  if ($[3] !== T0 || $[4] !== t1) {
-    t2 = <T0 value={t1} />;
-    $[3] = T0;
-    $[4] = t1;
+  if ($[2] !== num || $[3] !== t1) {
+    const arr = t1;
+    T0 = Stringify;
+    if ($[6] !== arr || $[7] !== num) {
+      t2 = arr.push(num);
+      $[6] = arr;
+      $[7] = num;
+      $[8] = t2;
+    } else {
+      t2 = $[8];
+    }
+    $[2] = num;
+    $[3] = t1;
+    $[4] = T0;
     $[5] = t2;
   } else {
+    T0 = $[4];
     t2 = $[5];
   }
-  return t2;
+  let t3;
+  if ($[9] !== T0 || $[10] !== t2) {
+    t3 = <T0 value={t2} />;
+    $[9] = T0;
+    $[10] = t2;
+    $[11] = t3;
+  } else {
+    t3 = $[11];
+  }
+  return t3;
 }
 
 export const FIXTURE_ENTRYPOINT = {