RuntimeExecutor: Fix sync js execution from main thread

Summary:
# Problem

Sync rendering/events (i.e: execute js now below), when used in conjunction with js -> ui sync calls, can deadlock react native:

## Deadlock #1
**Main thread**: execute js now:
  * Main thread puts a block on the js queue, to capture the runtime.
 * Main thread then then goes to sleep, waiting for runtime to be captured

**JS thread**: execute ui code synchronously:
* Js thread schedules a block on the ui thread
* Js thread then goes to sleep, waiting for that block to execute.
* **The application deadlocks**

| {F1978009555} |  {F1978009612} |

## Deadlock #2
**JS thread**: execute ui code synchronously:
* Js thread schedules a block on the ui thread
* Js thread then goes to sleep waiting for that block to execute.

**Main thread**: execute js now:
* Main thread puts a block on the js queue, to capture the runtime.
* Main thread then then goes to sleep, waiting for runtime to be captured
* **The application deadlocks.**

|  {F1978009690}  | {F1978009701} |

# Changes
This diff attempts to fix those deadlocks. How:
* This diff introduces a stateful "execute js now" coordinator.
* In "execute ui code synchronously" (js thread):
   * Before going to sleep, the js thread posts its ui work to the "execute js now" coordinator.
* In "execute js now" (main thread):
   * Before trying to capture the runtime, the main thread executes "pending ui work", if it exists.
   * While the main thread is sleeping, waiting for runtime capture, it can be woken up, and asked to execute "pending ui work."

## Mitigation: Deadlock #1
**Main thread**: execute js now:
* Main thread puts a block on the js queue, to capture the runtime.
* Main thread then then goes to sleep, waiting for runtime to be captured

**JS Thread**: execute ui code synchronously:
* Js thread schedules this block on the ui thread.
* ***New***: Js thread also assigns this block to the coordinator. *And wakes up the main thread*.
* Js thread goes to sleep.

The main thread wakes up:
* Main thread **executes** the ui block assigned to the coordinator. **This cancels the ui block scheduled on the main queue.**
* Main thread goes back to sleep.
* The js thread wakes up, moves on to the next task.

The runtime is captured by the main thread.

| {F1978010383} | {F1978010363} |  {F1978010371} |  {F1978010379}

## Mitigation: Deadlock #2
**JS Thread**: execute ui code synchronously:
* Js thread schedules this block on the ui thread.
* ***New***: Js thread also assigns this block to the coordinator. *And wakes up the main thread*.
* Js thread goes to sleep.

**Main thread**: execute js now
* Main thread executes the ui block immediately. (This cancels the ui block on the main queue).
* Js thread wakes up and moves onto the next task.

Main thread captures the runtime.

|  {F1978010525}  |  {F1978010533} |  {F1978010542} |

Differential Revision: D74769326

Author: RSNara

packages/react-native/ReactCommon/react/nativemodule/core/platform/ios/ReactCommon/RCTTurboModuleManager.h

@@ -71,7 +71,8 @@
 - (instancetype)initWithBridgeProxy:(RCTBridgeProxy *)bridgeProxy
               bridgeModuleDecorator:(RCTBridgeModuleDecorator *)bridgeModuleDecorator
                            delegate:(id<RCTTurboModuleManagerDelegate>)delegate
-                          jsInvoker:(std::shared_ptr<facebook::react::CallInvoker>)jsInvoker;
+                          jsInvoker:(std::shared_ptr<facebook::react::CallInvoker>)jsInvoker
+                         isJSThread:(std::function<bool()>)isJSThread;
 
 - (void)installJSBindings:(facebook::jsi::Runtime &)runtime;
 

packages/react-native/ReactCommon/react/nativemodule/core/platform/ios/ReactCommon/RCTTurboModuleManager.mm

@@ -29,10 +29,12 @@
 #import <React/RCTUtils.h>
 #import <ReactCommon/CxxTurboModuleUtils.h>
 #import <ReactCommon/RCTTurboModuleWithJSIBindings.h>
+#import <ReactCommon/RuntimeExecutorUtils.h>
 #import <ReactCommon/TurboCxxModule.h>
 #import <ReactCommon/TurboModulePerfLogger.h>
 #import <ReactCommon/TurboModuleUtils.h>
 #import <react/featureflags/ReactNativeFeatureFlags.h>
+#import <react/utils/OnScopeExit.h>
 
 using namespace facebook;
 using namespace facebook::react;
@@ -110,6 +112,27 @@ bool isCreatingModule() const
   }
 };
 
+void RCTExecuteOnMainQueueSyncFromJS(dispatch_block_t work)
+{
+  __block auto uiWorkDone = std::make_shared<std::mutex>();
+  __block auto uiWork = work;
+  auto wrapper = ^{
+    if (!uiWork) {
+      return;
+    }
+    OnScopeExit onScopeExit(^{
+      uiWork = nil;
+      uiWorkDone->lock();
+    });
+    uiWork();
+  };
+
+  uiWorkDone->lock();
+  RCTExecuteOnMainQueue(wrapper);
+  postIdleWork(wrapper);
+  uiWorkDone->lock();
+}
+
 class ModuleNativeMethodCallInvoker : public NativeMethodCallInvoker {
  private:
   dispatch_queue_t methodQueue_;
@@ -148,7 +171,7 @@ void invokeSync(const std::string &methodName, std::function<void()> &&work) ove
   {
     if (requiresMainQueueSetup_ && methodName == "getConstants") {
       __block auto retainedWork = std::move(work);
-      RCTUnsafeExecuteOnMainQueueSync(^{
+      RCTExecuteOnMainQueueSyncFromJS(^{
         retainedWork();
       });
       return;
@@ -215,6 +238,7 @@ @implementation RCTTurboModuleManager {
 
   RCTBridgeProxy *_bridgeProxy;
   RCTBridgeModuleDecorator *_bridgeModuleDecorator;
+  std::function<bool()> _isJSThread;
 
   dispatch_queue_t _sharedModuleQueue;
 }
@@ -224,9 +248,11 @@ - (instancetype)initWithBridge:(RCTBridge *)bridge
          bridgeModuleDecorator:(RCTBridgeModuleDecorator *)bridgeModuleDecorator
                       delegate:(id<RCTTurboModuleManagerDelegate>)delegate
                      jsInvoker:(std::shared_ptr<CallInvoker>)jsInvoker
+                    isJSThread:(std::function<bool()>)isJSThread
 {
   if (self = [super init]) {
     _jsInvoker = std::move(jsInvoker);
+    _isJSThread = isJSThread;
     _delegate = delegate;
     _bridge = bridge;
     _bridgeProxy = bridgeProxy;
@@ -276,19 +302,22 @@ - (instancetype)initWithBridge:(RCTBridge *)bridge
                   bridgeProxy:nil
         bridgeModuleDecorator:[bridge bridgeModuleDecorator]
                      delegate:delegate
-                    jsInvoker:jsInvoker];
+                    jsInvoker:jsInvoker
+                   isJSThread:nullptr];
 }
 
 - (instancetype)initWithBridgeProxy:(RCTBridgeProxy *)bridgeProxy
               bridgeModuleDecorator:(RCTBridgeModuleDecorator *)bridgeModuleDecorator
                            delegate:(id<RCTTurboModuleManagerDelegate>)delegate
                           jsInvoker:(std::shared_ptr<CallInvoker>)jsInvoker
+                         isJSThread:(std::function<bool()>)isJSThread
 {
   return [self initWithBridge:nil
                   bridgeProxy:bridgeProxy
         bridgeModuleDecorator:bridgeModuleDecorator
                      delegate:delegate
-                    jsInvoker:jsInvoker];
+                    jsInvoker:jsInvoker
+                   isJSThread:isJSThread];
 }
 
 /**
@@ -601,11 +630,11 @@ - (ModuleHolder *)_getOrCreateModuleHolder:(const char *)moduleName
       };
 
       if ([self _requiresMainQueueSetup:moduleClass]) {
-        NSString *message = [NSString
-            stringWithFormat:
-                @"Lazily setting up TurboModule \"%s\" on the main queue. This could deadlock react native, if it happens during sync rendering. Please fix this by avoiding lazy main queue setup.",
-                moduleName];
-        RCTUnsafeExecuteOnMainQueueSyncWithError(work, message);
+        if (_isJSThread && _isJSThread()) {
+          RCTExecuteOnMainQueueSyncFromJS(work);
+        } else {
+          RCTUnsafeExecuteOnMainQueueSync(work);
+        }
       } else {
         work();
       }

packages/react-native/ReactCommon/react/runtime/platform/ios/ReactCommon/RCTInstance.mm

@@ -325,118 +325,124 @@ - (void)_start
   _turboModuleManager = [[RCTTurboModuleManager alloc] initWithBridgeProxy:bridgeProxy
                                                      bridgeModuleDecorator:_bridgeModuleDecorator
                                                                   delegate:self
-                                                                 jsInvoker:jsCallInvoker];
+                                                                 jsInvoker:jsCallInvoker
+                                                                isJsThread:[threadId = [_jsThreadManager threadId]]() {
+                                                                  return std::this_thread::get_id() == threadId;
+                                                                }]
+};
 
 #if RCT_DEV
-  /**
-   * Instantiating DevMenu has the side-effect of registering
-   * shortcuts for CMD + d, CMD + i,  and CMD + n via RCTDevMenu.
-   * Therefore, when TurboModules are enabled, we must manually create this
-   * NativeModule.
-   */
-  [_turboModuleManager moduleForName:"RCTDevMenu"];
+/**
+ * Instantiating DevMenu has the side-effect of registering
+ * shortcuts for CMD + d, CMD + i,  and CMD + n via RCTDevMenu.
+ * Therefore, when TurboModules are enabled, we must manually create this
+ * NativeModule.
+ */
+[_turboModuleManager moduleForName:"RCTDevMenu"];
 #endif // end RCT_DEV
 
-  // Initialize RCTModuleRegistry so that TurboModules can require other TurboModules.
-  [_bridgeModuleDecorator.moduleRegistry setTurboModuleRegistry:_turboModuleManager];
+// Initialize RCTModuleRegistry so that TurboModules can require other TurboModules.
+[_bridgeModuleDecorator.moduleRegistry setTurboModuleRegistry:_turboModuleManager];
 
-  if (ReactNativeFeatureFlags::enableMainQueueModulesOnIOS()) {
-    /**
-     * Some native modules need to capture uikit objects on the main thread.
-     * Start initializing those modules on the main queue here. The JavaScript thread
-     * will wait until this module init finishes, before executing the js bundle.
-     */
-    NSArray<NSString *> *modulesRequiringMainQueueSetup = [_delegate unstableModulesRequiringMainQueueSetup];
+if (ReactNativeFeatureFlags::enableMainQueueModulesOnIOS()) {
+  /**
+   * Some native modules need to capture uikit objects on the main thread.
+   * Start initializing those modules on the main queue here. The JavaScript thread
+   * will wait until this module init finishes, before executing the js bundle.
+   */
+  NSArray<NSString *> *modulesRequiringMainQueueSetup = [_delegate unstableModulesRequiringMainQueueSetup];
 
-    std::shared_ptr<std::mutex> mutex = std::make_shared<std::mutex>();
-    std::shared_ptr<std::condition_variable> cv = std::make_shared<std::condition_variable>();
-    std::shared_ptr<bool> isReady = std::make_shared<bool>(false);
+  std::shared_ptr<std::mutex> mutex = std::make_shared<std::mutex>();
+  std::shared_ptr<std::condition_variable> cv = std::make_shared<std::condition_variable>();
+  std::shared_ptr<bool> isReady = std::make_shared<bool>(false);
 
-    _waitUntilModuleSetupComplete = ^{
-      std::unique_lock<std::mutex> lock(*mutex);
-      cv->wait(lock, [isReady] { return *isReady; });
-    };
+  _waitUntilModuleSetupComplete = ^{
+    std::unique_lock<std::mutex> lock(*mutex);
+    cv->wait(lock, [isReady] { return *isReady; });
+  };
 
-    // TODO(T218039767): Integrate perf logging into main queue module init
-    RCTExecuteOnMainQueue(^{
-      for (NSString *moduleName in modulesRequiringMainQueueSetup) {
-        [self->_bridgeModuleDecorator.moduleRegistry moduleForName:[moduleName UTF8String]];
-      }
+  // TODO(T218039767): Integrate perf logging into main queue module init
+  RCTExecuteOnMainQueue(^{
+    for (NSString *moduleName in modulesRequiringMainQueueSetup) {
+      [self->_bridgeModuleDecorator.moduleRegistry moduleForName:[moduleName UTF8String]];
+    }
 
-      RCTScreenSize();
-      RCTScreenScale();
+    RCTScreenSize();
+    RCTScreenScale();
 
-      std::lock_guard<std::mutex> lock(*mutex);
-      *isReady = true;
-      cv->notify_all();
-    });
-  }
+    std::lock_guard<std::mutex> lock(*mutex);
+    *isReady = true;
+    cv->notify_all();
+  });
+}
 
-  RCTLogSetBridgelessModuleRegistry(_bridgeModuleDecorator.moduleRegistry);
-  RCTLogSetBridgelessCallableJSModules(_bridgeModuleDecorator.callableJSModules);
-
-  auto contextContainer = std::make_shared<ContextContainer>();
-  [_delegate didCreateContextContainer:contextContainer];
-
-  contextContainer->insert(
-      "RCTImageLoader", facebook::react::wrapManagedObject([_turboModuleManager moduleForName:"RCTImageLoader"]));
-  contextContainer->insert(
-      "RCTEventDispatcher",
-      facebook::react::wrapManagedObject([_turboModuleManager moduleForName:"RCTEventDispatcher"]));
-  contextContainer->insert("RCTBridgeModuleDecorator", facebook::react::wrapManagedObject(_bridgeModuleDecorator));
-  contextContainer->insert(RuntimeSchedulerKey, std::weak_ptr<RuntimeScheduler>(_reactInstance->getRuntimeScheduler()));
-  contextContainer->insert("RCTBridgeProxy", facebook::react::wrapManagedObject(bridgeProxy));
-
-  _surfacePresenter = [[RCTSurfacePresenter alloc]
-        initWithContextContainer:contextContainer
-                 runtimeExecutor:bufferedRuntimeExecutor
-      bridgelessBindingsExecutor:std::optional(_reactInstance->getUnbufferedRuntimeExecutor())];
-
-  // This enables RCTViewRegistry in modules to return UIViews from its viewForReactTag method
-  __weak RCTSurfacePresenter *weakSurfacePresenter = _surfacePresenter;
-  [_bridgeModuleDecorator.viewRegistry_DEPRECATED setBridgelessComponentViewProvider:^UIView *(NSNumber *reactTag) {
-    RCTSurfacePresenter *strongSurfacePresenter = weakSurfacePresenter;
-    if (strongSurfacePresenter == nil) {
-      return nil;
-    }
+RCTLogSetBridgelessModuleRegistry(_bridgeModuleDecorator.moduleRegistry);
+RCTLogSetBridgelessCallableJSModules(_bridgeModuleDecorator.callableJSModules);
+
+auto contextContainer = std::make_shared<ContextContainer>();
+[_delegate didCreateContextContainer:contextContainer];
+
+contextContainer->insert(
+    "RCTImageLoader",
+    facebook::react::wrapManagedObject([_turboModuleManager moduleForName:"RCTImageLoader"]));
+contextContainer->insert(
+    "RCTEventDispatcher",
+    facebook::react::wrapManagedObject([_turboModuleManager moduleForName:"RCTEventDispatcher"]));
+contextContainer->insert("RCTBridgeModuleDecorator", facebook::react::wrapManagedObject(_bridgeModuleDecorator));
+contextContainer->insert(RuntimeSchedulerKey, std::weak_ptr<RuntimeScheduler>(_reactInstance->getRuntimeScheduler()));
+contextContainer->insert("RCTBridgeProxy", facebook::react::wrapManagedObject(bridgeProxy));
+
+_surfacePresenter = [[RCTSurfacePresenter alloc]
+      initWithContextContainer:contextContainer
+               runtimeExecutor:bufferedRuntimeExecutor
+    bridgelessBindingsExecutor:std::optional(_reactInstance->getUnbufferedRuntimeExecutor())];
+
+// This enables RCTViewRegistry in modules to return UIViews from its viewForReactTag method
+__weak RCTSurfacePresenter *weakSurfacePresenter = _surfacePresenter;
+[_bridgeModuleDecorator.viewRegistry_DEPRECATED setBridgelessComponentViewProvider:^UIView *(NSNumber *reactTag) {
+  RCTSurfacePresenter *strongSurfacePresenter = weakSurfacePresenter;
+  if (strongSurfacePresenter == nil) {
+    return nil;
+  }
 
-    return [strongSurfacePresenter findComponentViewWithTag_DO_NOT_USE_DEPRECATED:reactTag.integerValue];
-  }];
+  return [strongSurfacePresenter findComponentViewWithTag_DO_NOT_USE_DEPRECATED:reactTag.integerValue];
+}];
 
-  // DisplayLink is used to call timer callbacks.
-  _displayLink = [RCTDisplayLink new];
+// DisplayLink is used to call timer callbacks.
+_displayLink = [RCTDisplayLink new];
 
-  ReactInstance::JSRuntimeFlags options = {
-      .isProfiling = false, .runtimeDiagnosticFlags = [RCTInstanceRuntimeDiagnosticFlags() UTF8String]};
-  _reactInstance->initializeRuntime(options, [=](jsi::Runtime &runtime) {
-    __strong __typeof(self) strongSelf = weakSelf;
-    if (!strongSelf) {
-      return;
-    }
+ReactInstance::JSRuntimeFlags options = {
+    .isProfiling = false,
+    .runtimeDiagnosticFlags = [RCTInstanceRuntimeDiagnosticFlags() UTF8String]};
+_reactInstance->initializeRuntime(options, [=](jsi::Runtime &runtime) {
+  __strong __typeof(self) strongSelf = weakSelf;
+  if (!strongSelf) {
+    return;
+  }
 
-    [strongSelf->_turboModuleManager installJSBindings:runtime];
-    facebook::react::bindNativeLogger(runtime, [](const std::string &message, unsigned int logLevel) {
-      _RCTLogJavaScriptInternal(static_cast<RCTLogLevel>(logLevel), [NSString stringWithUTF8String:message.c_str()]);
-    });
-    RCTInstallNativeComponentRegistryBinding(runtime);
+  [strongSelf->_turboModuleManager installJSBindings:runtime];
+  facebook::react::bindNativeLogger(runtime, [](const std::string &message, unsigned int logLevel) {
+    _RCTLogJavaScriptInternal(static_cast<RCTLogLevel>(logLevel), [NSString stringWithUTF8String:message.c_str()]);
+  });
+  RCTInstallNativeComponentRegistryBinding(runtime);
 
-    if (ReactNativeFeatureFlags::useNativeViewConfigsInBridgelessMode()) {
-      installLegacyUIManagerConstantsProviderBinding(runtime);
-    }
+  if (ReactNativeFeatureFlags::useNativeViewConfigsInBridgelessMode()) {
+    installLegacyUIManagerConstantsProviderBinding(runtime);
+  }
 
-    [strongSelf->_delegate instance:strongSelf didInitializeRuntime:runtime];
+  [strongSelf->_delegate instance:strongSelf didInitializeRuntime:runtime];
 
-    // Set up Display Link
-    id<RCTDisplayLinkModuleHolder> moduleHolder = [[RCTBridgelessDisplayLinkModuleHolder alloc] initWithModule:timing];
-    [strongSelf->_displayLink registerModuleForFrameUpdates:timing withModuleHolder:moduleHolder];
-    [strongSelf->_displayLink addToRunLoop:[NSRunLoop currentRunLoop]];
+  // Set up Display Link
+  id<RCTDisplayLinkModuleHolder> moduleHolder = [[RCTBridgelessDisplayLinkModuleHolder alloc] initWithModule:timing];
+  [strongSelf->_displayLink registerModuleForFrameUpdates:timing withModuleHolder:moduleHolder];
+  [strongSelf->_displayLink addToRunLoop:[NSRunLoop currentRunLoop]];
 
-    // Attempt to load bundle synchronously, fallback to asynchronously.
-    [strongSelf->_performanceLogger markStartForTag:RCTPLScriptDownload];
-    [strongSelf _loadJSBundle:[strongSelf->_bridgeModuleDecorator.bundleManager bundleURL]];
-  });
+  // Attempt to load bundle synchronously, fallback to asynchronously.
+  [strongSelf->_performanceLogger markStartForTag:RCTPLScriptDownload];
+  [strongSelf _loadJSBundle:[strongSelf->_bridgeModuleDecorator.bundleManager bundleURL]];
+});
 
-  [_performanceLogger markStopForTag:RCTPLReactInstanceInit];
+[_performanceLogger markStopForTag:RCTPLReactInstanceInit];
 }
 
 - (void)_attachBridgelessAPIsToModule:(id<RCTTurboModule>)module

packages/react-native/ReactCommon/react/runtime/platform/ios/ReactCommon/RCTJSThreadManager+Internal.h

@@ -0,0 +1,19 @@
+/*
+ * 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.
+ */
+
+#import <Foundation/Foundation.h>
+
+#import <thread>
+#import "RCTJSThreadManager.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RCTJSThreadManager ()
+- (std::thread::id)threadId;
+@end
+
+NS_ASSUME_NONNULL_END

packages/react-native/ReactCommon/react/runtime/platform/ios/ReactCommon/RCTJSThreadManager.mm

@@ -6,6 +6,7 @@
  */
 
 #import "RCTJSThreadManager.h"
+#import "RCTJSThreadManager+Internal.h"
 
 #import <React/RCTAssert.h>
 #import <React/RCTCxxUtils.h>
@@ -18,6 +19,7 @@
 @implementation RCTJSThreadManager {
   NSThread *_jsThread;
   std::shared_ptr<facebook::react::RCTMessageThread> _jsMessageThread;
+  std::thread::id _threadId;
 }
 
 - (instancetype)init
@@ -28,6 +30,7 @@ - (instancetype)init
 
     dispatch_block_t captureJSThreadRunLoop = ^(void) {
       __strong RCTJSThreadManager *strongSelf = weakSelf;
+      strongSelf->_threadId = std::this_thread::get_id();
       strongSelf->_jsMessageThread =
           std::make_shared<facebook::react::RCTMessageThread>([NSRunLoop currentRunLoop], ^(NSError *error) {
             if (error) {
@@ -106,6 +109,12 @@ + (void)runRunLoop
   }
 }
 
+#pragma mark - Internal
+- (std::thread::id)threadId
+{
+  return _threadId;
+}
+
 #pragma mark - Private
 
 - (void)_handleError:(NSError *)error