C++ Turbo Module > Allow Promise<void> types (#52388)

Summary:
Pull Request resolved: #52388

Changelog: [Internal]

Similar to `AsyncCallback<>` (the foundation of `AsyncPromise`) we should allow `void` Promise types in C++ such as `AsyncPromise<>`

Reviewed By: rbergerjr

Differential Revision: D77712020

fbshipit-source-id: d7360df5cc1b77f1e03e5fb73b0b468f6e3a415b

Author: christophpurrer

packages/react-native/ReactCommon/react/bridging/Promise.h

@@ -16,8 +16,12 @@
 
 namespace facebook::react {
 
-template <typename T>
+template <typename... T>
 class AsyncPromise {
+  static_assert(
+      sizeof...(T) <= 1,
+      "AsyncPromise must have at most one argument");
+
  public:
   AsyncPromise(jsi::Runtime& rt, const std::shared_ptr<CallInvoker>& jsInvoker)
       : state_(std::make_shared<SharedState>()) {
@@ -28,7 +32,9 @@ class AsyncPromise {
         bridging::toJs(
             rt,
             // Safe to capture this since this is called synchronously.
-            [this](AsyncCallback<T> resolve, AsyncCallback<Error> reject) {
+            [this](
+                AsyncCallback<T...> resolve,
+                const AsyncCallback<Error>& reject) {
               state_->resolve = std::move(resolve);
               state_->reject = std::move(reject);
             },
@@ -42,11 +48,11 @@ class AsyncPromise {
     state_->promiseHolder = promiseHolder;
   }
 
-  void resolve(T value) {
+  void resolve(T... value) {
     std::lock_guard<std::mutex> lock(state_->mutex);
 
     if (state_->resolve) {
-      state_->resolve->call(std::move(value));
+      state_->resolve->call(std::forward<T>(value)...);
       state_->resolve.reset();
       state_->reject.reset();
     }
@@ -87,16 +93,16 @@ class AsyncPromise {
 
     std::mutex mutex;
     std::weak_ptr<PromiseHolder> promiseHolder;
-    std::optional<AsyncCallback<T>> resolve;
+    std::optional<AsyncCallback<T...>> resolve;
     std::optional<AsyncCallback<Error>> reject;
   };
 
   std::shared_ptr<SharedState> state_;
 };
 
-template <typename T>
-struct Bridging<AsyncPromise<T>> {
-  static jsi::Object toJs(jsi::Runtime& rt, const AsyncPromise<T>& promise) {
+template <typename... T>
+struct Bridging<AsyncPromise<T...>> {
+  static jsi::Object toJs(jsi::Runtime& rt, const AsyncPromise<T...>& promise) {
     return promise.get(rt);
   }
 };

packages/rn-tester/NativeCxxModuleExample/NativeCxxModuleExample.cpp

@@ -177,6 +177,12 @@ void NativeCxxModuleExample::voidFunc(jsi::Runtime& rt) {
   emitOnEvent(NativeCxxModuleExampleEnumNone::NA);
 }
 
+AsyncPromise<> NativeCxxModuleExample::voidPromise(jsi::Runtime& rt) {
+  AsyncPromise<> promise(rt, jsInvoker_);
+  promise.resolve();
+  return promise;
+}
+
 void NativeCxxModuleExample::setMenu(jsi::Runtime& rt, MenuItem menuItem) {
   menuItem.onPress("value", true);
   if (menuItem.items) {
@@ -213,8 +219,7 @@ ObjectStruct NativeCxxModuleExample::getObjectThrows(
   throw std::runtime_error("Intentional exception from Cxx getObjectThrows");
 };
 
-AsyncPromise<jsi::Value> NativeCxxModuleExample::promiseThrows(
-    jsi::Runtime& rt) {
+AsyncPromise<> NativeCxxModuleExample::promiseThrows(jsi::Runtime& rt) {
   throw std::runtime_error("Intentional exception from Cxx promiseThrows");
 };
 
@@ -231,12 +236,11 @@ ObjectStruct NativeCxxModuleExample::getObjectAssert(
   return {};
 };
 
-AsyncPromise<jsi::Value> NativeCxxModuleExample::promiseAssert(
-    jsi::Runtime& rt) {
+AsyncPromise<> NativeCxxModuleExample::promiseAssert(jsi::Runtime& rt) {
   react_native_assert(false && "Intentional assert from Cxx promiseAssert");
 
   // Asserts disabled
-  auto promise = AsyncPromise<jsi::Value>(rt, jsInvoker_);
+  auto promise = AsyncPromise<>(rt, jsInvoker_);
   promise.reject("Asserts disabled");
   return promise;
 };

packages/rn-tester/NativeCxxModuleExample/NativeCxxModuleExample.h

@@ -193,6 +193,8 @@ class NativeCxxModuleExample
 
   void voidFunc(jsi::Runtime& rt);
 
+  AsyncPromise<> voidPromise(jsi::Runtime& rt);
+
   void setMenu(jsi::Runtime& rt, MenuItem menuItem);
 
   void emitCustomDeviceEvent(jsi::Runtime& rt, const std::string& eventName);
@@ -201,13 +203,13 @@ class NativeCxxModuleExample
 
   ObjectStruct getObjectThrows(jsi::Runtime& rt, ObjectStruct arg);
 
-  AsyncPromise<jsi::Value> promiseThrows(jsi::Runtime& rt);
+  AsyncPromise<> promiseThrows(jsi::Runtime& rt);
 
   void voidFuncAssert(jsi::Runtime& rt);
 
   ObjectStruct getObjectAssert(jsi::Runtime& rt, ObjectStruct arg);
 
-  AsyncPromise<jsi::Value> promiseAssert(jsi::Runtime& rt);
+  AsyncPromise<> promiseAssert(jsi::Runtime& rt);
 
  private:
   std::optional<AsyncCallback<std::string>> valueCallback_;

packages/rn-tester/NativeCxxModuleExample/NativeCxxModuleExample.js

@@ -105,6 +105,7 @@ export interface Spec extends TurboModule {
   +getValueWithPromise: (error: boolean) => Promise<string>;
   +getWithWithOptionalArgs: (optionalArg?: boolean) => ?boolean;
   +voidFunc: () => void;
+  +voidPromise: () => Promise<void>;
   +setMenu: (menuItem: MenuItem) => void;
   +emitCustomDeviceEvent: (eventName: string) => void;
   +voidFuncThrows: () => void;

packages/rn-tester/js/examples/TurboModule/NativeCxxModuleExampleExample.js

@@ -58,6 +58,7 @@ type Examples =
   | 'promise'
   | 'rejectPromise'
   | 'voidFunc'
+  | 'voidPromise'
   | 'setMenuItem'
   | 'optionalArgs'
   | 'emitDeviceEvent';
@@ -138,6 +139,10 @@ class NativeCxxModuleExampleExample extends React.Component<{}, State> {
         .then(() => {})
         .catch(e => this._setResult('rejectPromise', e.message)),
     voidFunc: () => NativeCxxModuleExample?.voidFunc(),
+    voidPromise: () =>
+      NativeCxxModuleExample?.voidPromise().then(valuePromise =>
+        this._setResult('voidPromise', valuePromise),
+      ),
     setMenuItem: () => {
       let curValue = '';
       NativeCxxModuleExample?.setMenu({