Babel preset: Add Hermes V1 native runtime workarounds for hermes#1761

## Summary:

Three Babel plugins added to `@react-native/babel-preset` that work
around runtime codegen bugs in the bundled Hermes V1 (250829098.0.13,
branch cut 2025-08-29) by rewriting source patterns before they reach
the engine. Each plugin papers over a different bug that is fixed on
Hermes `static_h` but has not been backported to the V1 stable branch
(verified absent through the .0.15 stable tip; the only in-flight graft,
facebook/hermes#2030, is still open).

- `fix-hermes-v1-async-arrow-non-simple-params`:
  facebook/hermes#1761 (fixed in static_h by 68bfb3a48b31, 2025-09-11).
  Async arrow functions with destructured, defaulted, or rest parameters
  silently resolve `await` with `undefined` while the function body
  continues executing in the background. The plugin rewrites the params
  to a simple identifier with inline destructuring so Hermes never sees
  the buggy shape. Gated on `isHermesProfile && preserveAsync` since
  `plugin-transform-async-to-generator` rewrites the pattern away when
  `preserveAsync` is false.

- `fix-hermes-v1-class-in-finally`:
  Fixed in static_h by 1e94fbe0ebb4 (2026-02-12). Class declarations
  inside a `finally` block trip Hermes V1's variable caching path. The
  plugin wraps them in an IIFE so the class lives in its own scope, and
  preserves the inferred name of a class expression bound to a plain
  identifier.

- `fix-hermes-v1-super-in-object-accessor`:
  Fixed in static_h by 18a963465944 (2025-11-04). Object-literal getters
  and setters using `super.x` trip the `genFunctionExpression` home
  object path, which segfaults hermesc at compile time. The plugin marks
  the accessor as computed with a string key, covering identifier,
  string, and numeric keys.

All three gate on `isHermesProfile` and bail out fast on the common
case. The plugins are a direct port of work by @kitten (Phil Pluckthun,
Expo team) in `babel-preset-expo` (expo/expo#45601, MIT licensed). All
plugin design and implementation credit belongs to him. This PR carries
his work over to `@react-native/babel-preset` so bare React Native
consumers benefit from the same fix.

## Changelog:

[GENERAL] [FIXED] - Work around three Hermes V1 source-level codegen bugs in `@react-native/babel-preset` (async-arrow non-simple params, class-in-finally, super-in-object-accessor)

## Test Plan:

- 21 inline-snapshot test cases across three new test files verify the transformed output, the fast-bail behavior on irrelevant patterns, and the numeric-key and class-name edge cases.
- `yarn jest packages/react-native-babel-preset` clean (76 tests, 27 snapshots).
- Full repo `yarn test` clean (278 suites, 5692 tests passed, 1857 snapshots).
- `yarn lint`, `yarn format-check`, `yarn flow-check`, `yarn test-typescript`, `yarn featureflags --verify-unchanged`, `yarn build-types --validate` all clean.
- Existing `transform-snapshot-test` passes byte-identical: the kitchen-sink fixture has none of the buggy patterns so the new plugins do not change its output for any profile.
- Compiled the bug patterns through the bundled compiler (hermes-compiler 250829098.0.14): `get x() { return super.x }` and `get 0() { return super.x }` both segfault hermesc, while the transformed computed-key output compiles clean.
- Device repro at ramonclaudio/hermes-1761-repro: 55/55 PASS on iPhone 17 Pro / iOS 26.5 in Debug and Release.

## Caveats:

`fix-hermes-v1-class-in-finally` rewrites block-scoped `class`
declarations inside `finally` blocks to function-scoped `var`
initializers, matching the babel-preset-expo source. Observable only
when code in the same `finally` references the class before its
declaration or relies on its block scoping (rare). The same plugin shape
has shipped in `babel-preset-expo` and Expo SDK 56 without reported
regressions, but flagging in case Meta's internal test fleet surfaces an
edge case the OSS suite does not catch.

## References:

- facebook/hermes#1761 (root-cause issue, fixed in static_h)
- facebook/hermes#2030 (in-flight graft of the async-arrow fix onto the V1 stable branch, still open)
- expo/expo#45601 (source of the ported plugins, by @kitten)
- expo/expo#45592 (user-facing bug report on SDK 56 preview)

Co-authored-by: Phil Pluckthun <phil@kitten.sh>

Author: ramonclaudio

packages/react-native-babel-preset/src/__tests__/fix-hermes-v1-async-arrow-non-simple-params-test.js

@@ -0,0 +1,115 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @noflow
+ */
+
+'use strict';
+
+const {transform} = require('../__mocks__/test-helpers');
+const fixHermesV1AsyncArrowNonSimpleParams = require('../fix-hermes-v1-async-arrow-non-simple-params');
+
+test('rewrites destructured object param with default to simple identifier', () => {
+  const code = `
+    const fn = async ({a = 1, b} = {}) => {
+      return await fetch(a + b);
+    };
+  `;
+
+  expect(transform(code, [fixHermesV1AsyncArrowNonSimpleParams]))
+    .toMatchInlineSnapshot(`
+    "const fn = async _p => {
+      var {
+        a = 1,
+        b
+      } = _p === undefined ? {} : _p;
+      return await fetch(a + b);
+    };"
+  `);
+});
+
+test('rewrites destructured array param to simple identifier', () => {
+  const code = `
+    const fn = async ([a, b]) => await Promise.resolve(a + b);
+  `;
+
+  expect(transform(code, [fixHermesV1AsyncArrowNonSimpleParams]))
+    .toMatchInlineSnapshot(`
+    "const fn = async _p => {
+      var [a, b] = _p;
+      return await Promise.resolve(a + b);
+    };"
+  `);
+});
+
+test('rewrites assignment-pattern param without enclosing destructure', () => {
+  const code = `
+    const fn = async (x = 5) => await use(x);
+  `;
+
+  expect(transform(code, [fixHermesV1AsyncArrowNonSimpleParams]))
+    .toMatchInlineSnapshot(`
+    "const fn = async _p => {
+      var x = _p === undefined ? 5 : _p;
+      return await use(x);
+    };"
+  `);
+});
+
+test('wraps body in inner async arrow when rest param is present', () => {
+  const code = `
+    const fn = async (...args) => await handle(args);
+  `;
+
+  expect(transform(code, [fixHermesV1AsyncArrowNonSimpleParams]))
+    .toMatchInlineSnapshot(`
+    "const fn = (...args) => (async () => {
+      return await handle(args);
+    })();"
+  `);
+});
+
+test('leaves async arrow with only simple identifier params alone', () => {
+  const code = `
+    const fn = async (a, b) => await fetch(a + b);
+  `;
+
+  expect(
+    transform(code, [fixHermesV1AsyncArrowNonSimpleParams]),
+  ).toMatchInlineSnapshot(`"const fn = async (a, b) => await fetch(a + b);"`);
+});
+
+test('leaves non-async arrow alone', () => {
+  const code = `
+    const fn = ({a = 1, b} = {}) => a + b;
+  `;
+
+  expect(transform(code, [fixHermesV1AsyncArrowNonSimpleParams]))
+    .toMatchInlineSnapshot(`
+    "const fn = ({
+      a = 1,
+      b
+    } = {}) => a + b;"
+  `);
+});
+
+test('handles multiple params mixing simple and complex', () => {
+  const code = `
+    const fn = async (a, {b}, c = 1) => await all(a, b, c);
+  `;
+
+  expect(transform(code, [fixHermesV1AsyncArrowNonSimpleParams]))
+    .toMatchInlineSnapshot(`
+    "const fn = async (a, _p, _p2) => {
+      var {
+        b
+      } = _p;
+      var c = _p2 === undefined ? 1 : _p2;
+      return await all(a, b, c);
+    };"
+  `);
+});

packages/react-native-babel-preset/src/__tests__/fix-hermes-v1-class-in-finally-test.js

@@ -0,0 +1,181 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @noflow
+ */
+
+'use strict';
+
+const {transform} = require('../__mocks__/test-helpers');
+const fixHermesV1ClassInFinally = require('../fix-hermes-v1-class-in-finally');
+
+test('wraps class declaration in finally block in IIFE', () => {
+  const code = `
+    function run() {
+      try {
+        risky();
+      } finally {
+        class Logger {
+          log() { console.log('done'); }
+        }
+        new Logger().log();
+      }
+    }
+  `;
+
+  expect(transform(code, [fixHermesV1ClassInFinally])).toMatchInlineSnapshot(`
+    "function run() {
+      try {
+        risky();
+      } finally {
+        var Logger = (() => {
+          class Logger {
+            log() {
+              console.log('done');
+            }
+          }
+          return Logger;
+        })();
+        new Logger().log();
+      }
+    }"
+  `);
+});
+
+test('wraps class expression in finally block in IIFE', () => {
+  const code = `
+    function run() {
+      try {
+        risky();
+      } finally {
+        const Logger = class {
+          log() {}
+        };
+        new Logger().log();
+      }
+    }
+  `;
+
+  expect(transform(code, [fixHermesV1ClassInFinally])).toMatchInlineSnapshot(`
+"function run() {
+  try {
+    risky();
+  } finally {
+    const Logger = (() => class Logger {
+      log() {}
+    })();
+    new Logger().log();
+  }
+}"
+`);
+});
+
+test('leaves class outside finally block alone', () => {
+  const code = `
+    function run() {
+      try {
+        class Inside {}
+        return new Inside();
+      } catch (e) {
+        class Caught {}
+        return new Caught();
+      }
+    }
+  `;
+
+  expect(transform(code, [fixHermesV1ClassInFinally])).toMatchInlineSnapshot(`
+    "function run() {
+      try {
+        class Inside {}
+        return new Inside();
+      } catch (e) {
+        class Caught {}
+        return new Caught();
+      }
+    }"
+  `);
+});
+
+test('leaves class declared at module scope alone', () => {
+  const code = `
+    class Module {}
+    new Module();
+  `;
+
+  expect(transform(code, [fixHermesV1ClassInFinally])).toMatchInlineSnapshot(`
+    "class Module {}
+    new Module();"
+  `);
+});
+
+test('does not enter nested function scope', () => {
+  const code = `
+    try {} finally {
+      function inner() {
+        class NestedFn {}
+        return new NestedFn();
+      }
+      inner();
+    }
+  `;
+
+  expect(transform(code, [fixHermesV1ClassInFinally])).toMatchInlineSnapshot(`
+    "try {} finally {
+      function inner() {
+        class NestedFn {}
+        return new NestedFn();
+      }
+      inner();
+    }"
+  `);
+});
+
+test('preserves inferred name when wrapping a named-binding class expression', () => {
+  const code = `
+    function run() {
+      try {} finally {
+        const Service = class {
+          ping() {}
+        };
+        return new Service();
+      }
+    }
+  `;
+
+  expect(transform(code, [fixHermesV1ClassInFinally])).toMatchInlineSnapshot(`
+"function run() {
+  try {} finally {
+    const Service = (() => class Service {
+      ping() {}
+    })();
+    return new Service();
+  }
+}"
+`);
+});
+
+test('leaves an unbound class expression in finally anonymous', () => {
+  const code = `
+    function run() {
+      try {} finally {
+        return register(class {
+          run() {}
+        });
+      }
+    }
+  `;
+
+  expect(transform(code, [fixHermesV1ClassInFinally])).toMatchInlineSnapshot(`
+"function run() {
+  try {} finally {
+    return register((() => class {
+      run() {}
+    })());
+  }
+}"
+`);
+});