Install globalEvalWithSourceUrl on bridgeless ReactInstance (#58718)

Summary:
**Problem:** On the New Architecture (bridgeless), fetching and evaluating a Metro split bundle in development (`lazy=true`, `import()`, `React.lazy()`) can fail with:

```
SyntaxError: Parsing source code unsupported: __d(function (global, require, _
```

The main bundle still loads.

**Root cause:** `global.globalEvalWithSourceUrl` is never installed on bridgeless. Bridge mode installs it in `JSIExecutor::initializeRuntime`.

```js
typeof global.globalEvalWithSourceUrl
// bridgeless: "undefined"
// bridge:     "function"
```

The debug loader (`Libraries/Core/Devtools/loadBundleFromServer.js`) prefers that helper and only falls back to JS `eval()` when it is missing. The two paths are not equivalent in Hermes:

- `eval()` / `Function` go through `evalInEnvironment`, which raises `Parsing source code unsupported` when `RuntimeConfig::EnableEval` is false (and, on legacy Hermes, when the engine is built lean).
- `globalEvalWithSourceUrl` goes through `Runtime::evaluateJavaScript`, the same entry point used to run the main bundle. It is not gated by `EnableEval`, and it attaches the given source URL to stack traces.

So on a runtime where `EnableEval` is off (or the engine is lean), the main bundle loads but every split bundle falls into `eval()` and throws. Bridgeless has no way to reach the JSI path from JS today.

**Fix:** Port the existing `JSIExecutor` binding into `ReactInstance::initializeRuntime` so bridgeless exposes the same helper.

## Changelog:

[General] [Fixed] - Install globalEvalWithSourceUrl on bridgeless ReactInstance so debug bundle loaders can evaluate split bundles via JSI instead of eval()

Pull Request resolved: #58718

Test Plan:
1. `ReactInstanceTest.testGlobalEvalWithSourceUrlIsInstalled`: helper is absent before `initializeRuntime` and present after.
2. `ReactInstanceTest.testGlobalEvalWithSourceUrlMatchesEvalWhenEvalIsEnabled`: with the default `RuntimeConfig`, `eval('1 + 2')` and `globalEvalWithSourceUrl('1 + 2', 'chunk.js')` both return `3`.
3. `ReactInstanceWithoutEvalTest.testGlobalEvalWithSourceUrlWorksWhenEvalIsDisabled`: runtime built with `RuntimeConfig::Builder().withEnableEval(false)`; `eval('1 + 2')` throws `Parsing source code unsupported`, `globalEvalWithSourceUrl('1 + 2', 'chunk.js')` returns `3`.
4. Fantom `Libraries/Core/Devtools/__tests__/globalEvalWithSourceUrl-itest.js`: helper is installed on bridgeless; `eval()` and the helper evaluate the same source to the same result; an error thrown from the helper carries the given source URL in its stack while the `eval()` one does not; wrong arity throws.
5. In a bridgeless debug app, `typeof global.globalEvalWithSourceUrl` is `'function'` and a `React.lazy(() => import('./SomeModule'))` split bundle loads without `Parsing source code unsupported`.

Reviewed By: fabriziocucci

Differential Revision: D122329977

Pulled By: javache

fbshipit-source-id: 789294c7806a331828effd407588208a55e1d9a3

Author: abzokhattab

packages/react-native/Libraries/Core/Devtools/__tests__/globalEvalWithSourceUrl-itest.js

@@ -0,0 +1,82 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ * @format
+ */
+
+import '@react-native/fantom/src/setUpDefaultReactNativeEnvironment';
+
+// Must not be a substring of this test's own bundle URL, which appears in
+// every stack trace.
+const SOURCE_URL = 'split-chunk-under-test.bundle';
+
+function getHelper(): (code: string, sourceUrl?: string) => unknown {
+  // $FlowFixMe[prop-missing]
+  const helper = global.globalEvalWithSourceUrl;
+  if (typeof helper !== 'function') {
+    throw new Error(
+      `Expected global.globalEvalWithSourceUrl to be a function, got ${typeof helper}`,
+    );
+  }
+  return helper;
+}
+
+function getStack(fn: () => unknown): string {
+  try {
+    fn();
+  } catch (e) {
+    return String(e?.stack ?? '');
+  }
+  throw new Error('Expected the evaluated code to throw');
+}
+
+describe('globalEvalWithSourceUrl', () => {
+  afterEach(() => {
+    // $FlowFixMe[prop-missing]
+    delete globalThis.__fantomEvalMarker;
+  });
+
+  it('is installed on the bridgeless runtime', () => {
+    // $FlowFixMe[prop-missing]
+    expect(typeof global.globalEvalWithSourceUrl).toBe('function');
+  });
+
+  it('evaluates the same source as JS eval() in the global scope', () => {
+    const source = 'globalThis.__fantomEvalMarker = 17; 17';
+
+    // eslint-disable-next-line no-eval
+    expect(eval(source)).toBe(17);
+    // $FlowFixMe[prop-missing]
+    expect(globalThis.__fantomEvalMarker).toBe(17);
+
+    // $FlowFixMe[prop-missing]
+    delete globalThis.__fantomEvalMarker;
+
+    expect(getHelper()(source, SOURCE_URL)).toBe(17);
+    // $FlowFixMe[prop-missing]
+    expect(globalThis.__fantomEvalMarker).toBe(17);
+  });
+
+  it('attributes evaluated code to the given source URL, unlike eval()', () => {
+    const source = 'throw new Error("thrown from evaluated source")';
+
+    // eslint-disable-next-line no-eval
+    const evalStack = getStack(() => eval(source));
+    const helperStack = getStack(() => getHelper()(source, SOURCE_URL));
+
+    expect(evalStack).not.toContain(SOURCE_URL);
+    expect(helperStack).toContain(SOURCE_URL);
+  });
+
+  it('rejects an invalid argument count', () => {
+    const helper = getHelper();
+    // $FlowFixMe[incompatible-type]
+    expect(() => helper()).toThrow(
+      'globalEvalWithSourceUrl arg count must be 1 or 2',
+    );
+  });
+});

packages/react-native/ReactCommon/react/runtime/ReactInstance.cpp

@@ -458,6 +458,39 @@ void ReactInstance::initializeRuntime(
 
     defineReactInstanceFlags(runtime, options);
 
+    // Bridge JSIExecutor installs this so debug bundle loaders can evaluate
+    // fetched Metro source through Runtime::evaluateJavaScript, with a source
+    // URL for stack traces. Unlike JS eval(), that path is not disabled by
+    // Hermes' RuntimeConfig::EnableEval or by lean engine builds. Left
+    // writable, like in JSIExecutor, so hosts can override or wrap it.
+    runtime.global().setProperty(
+        runtime,
+        "globalEvalWithSourceUrl",
+        jsi::Function::createFromHostFunction(
+            runtime,
+            jsi::PropNameID::forAscii(runtime, "globalEvalWithSourceUrl"),
+            2,
+            [](jsi::Runtime& rt,
+               const jsi::Value& /*thisValue*/,
+               const jsi::Value* args,
+               size_t count) {
+              if (count != 1 && count != 2) {
+                throw jsi::JSError(
+                    rt, "globalEvalWithSourceUrl arg count must be 1 or 2");
+              }
+
+              // NOLINTBEGIN(cppcoreguidelines-pro-bounds-pointer-arithmetic)
+              auto code = args[0].asString(rt).utf8(rt);
+              std::string url;
+              if (count > 1 && args[1].isString()) {
+                url = args[1].asString(rt).utf8(rt);
+              }
+              // NOLINTEND(cppcoreguidelines-pro-bounds-pointer-arithmetic)
+
+              return rt.evaluateJavaScript(
+                  std::make_unique<jsi::StringBuffer>(std::move(code)), url);
+            }));
+
     defineReadOnlyGlobal(
         runtime,
         "RN$useAlwaysAvailableJSErrorHandling",

packages/react-native/ReactCommon/react/runtime/tests/cxx/ReactInstanceTest.cpp

@@ -118,9 +118,13 @@ class ReactInstanceTest : public ::testing::Test {
  protected:
   ReactInstanceTest() = default;
 
+  virtual ::hermes::vm::RuntimeConfig makeRuntimeConfig() {
+    return {};
+  }
+
   void SetUp() override {
-    auto runtime =
-        std::make_unique<JSIRuntimeHolder>(hermes::makeHermesRuntime());
+    auto runtime = std::make_unique<JSIRuntimeHolder>(
+        hermes::makeHermesRuntime(makeRuntimeConfig()));
     runtime_ = &runtime->getRuntime();
     messageQueueThread_ = std::make_shared<MockMessageQueueThread>();
     auto mockRegistry = std::make_unique<MockTimerRegistry>();
@@ -255,6 +259,53 @@ TEST_F(ReactInstanceTest, testBridgelessFlagIsSet) {
   EXPECT_EQ(val.getBool(), true);
 }
 
+TEST_F(ReactInstanceTest, testGlobalEvalWithSourceUrlIsInstalled) {
+  auto before =
+      tryEval("typeof globalEvalWithSourceUrl === 'function'", "false");
+  EXPECT_EQ(before.getBool(), false);
+  initializeRuntimeWithScript("");
+  auto isFn = eval("typeof globalEvalWithSourceUrl === 'function'");
+  EXPECT_EQ(isFn.getBool(), true);
+  auto result = eval("globalEvalWithSourceUrl('1 + 2')");
+  EXPECT_EQ(result.getNumber(), 3);
+}
+
+TEST_F(
+    ReactInstanceTest,
+    testGlobalEvalWithSourceUrlMatchesEvalWhenEvalIsEnabled) {
+  initializeRuntimeWithScript("");
+
+  EXPECT_EQ(eval("eval('1 + 2')").getNumber(), 3);
+  EXPECT_EQ(
+      eval("globalEvalWithSourceUrl('1 + 2', 'chunk.js')").getNumber(), 3);
+}
+
+// Hermes gates eval() and the Function constructor behind
+// RuntimeConfig::EnableEval, but Runtime::evaluateJavaScript is not gated.
+// globalEvalWithSourceUrl goes through the latter, which is why the debug
+// bundle loaders prefer it over eval().
+class ReactInstanceWithoutEvalTest : public ReactInstanceTest {
+ protected:
+  ::hermes::vm::RuntimeConfig makeRuntimeConfig() override {
+    return ::hermes::vm::RuntimeConfig::Builder().withEnableEval(false).build();
+  }
+};
+
+TEST_F(
+    ReactInstanceWithoutEvalTest,
+    testGlobalEvalWithSourceUrlWorksWhenEvalIsDisabled) {
+  initializeRuntimeWithScript("");
+
+  auto evalOutcome = eval(
+      "(function() { try { eval('1 + 2'); return 'no error'; } catch (e) { return String(e.message); } })()");
+  EXPECT_THAT(
+      evalOutcome.getString(*runtime_).utf8(*runtime_),
+      HasSubstr("Parsing source code unsupported"));
+
+  EXPECT_EQ(
+      eval("globalEvalWithSourceUrl('1 + 2', 'chunk.js')").getNumber(), 3);
+}
+
 TEST_F(ReactInstanceTest, testProfilingFlag) {
   auto valBefore = tryEval("__RCTProfileIsProfiling === true", "false");
   EXPECT_EQ(valBefore.getBool(), false);