From 6697b7bb906faf0806fe672e7ea4ec73444e0800 Mon Sep 17 00:00:00 2001
From: Scott Kyle <skyle@fb.com>
Date: Fri, 11 Mar 2022 12:47:51 -0800
Subject: [PATCH] Add callFromJs bridging API

Summary:
This adds `bridging::callFromJs` that can call class instance methods with JSI arguments and will automagically convert types to the types expected by the method, or otherwise will fail to compile. The same type conversion back to JSI applies as well for the return value, if there is one.

This will allow C++ TurboModules to more easily define their interface in terms of C++ types instead of having to interact with JSI directly for everything, though it remains possibles for JSI values to pass through if that's what a given method wants.

Changelog:
Internal

Reviewed By: christophpurrer

Differential Revision: D34780511

fbshipit-source-id: 1f9caadeefa6d4023f679e95f3decc64d156b3f0
---
 ReactCommon/react/bridging/Bridging.h         |  1 +
 ReactCommon/react/bridging/Class.h            | 55 +++++++++++
 .../react/bridging/tests/ClassTest.cpp        | 97 +++++++++++++++++++
 3 files changed, 153 insertions(+)
 create mode 100644 ReactCommon/react/bridging/Class.h
 create mode 100644 ReactCommon/react/bridging/tests/ClassTest.cpp

diff --git a/ReactCommon/react/bridging/Bridging.h b/ReactCommon/react/bridging/Bridging.h
index 340ad0dee56..b0ba75c55da 100644
--- a/ReactCommon/react/bridging/Bridging.h
+++ b/ReactCommon/react/bridging/Bridging.h
@@ -9,6 +9,7 @@
 
 #include <react/bridging/Array.h>
 #include <react/bridging/Bool.h>
+#include <react/bridging/Class.h>
 #include <react/bridging/Error.h>
 #include <react/bridging/Function.h>
 #include <react/bridging/Number.h>
diff --git a/ReactCommon/react/bridging/Class.h b/ReactCommon/react/bridging/Class.h
new file mode 100644
index 00000000000..bb1afd00a8c
--- /dev/null
+++ b/ReactCommon/react/bridging/Class.h
@@ -0,0 +1,55 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <react/bridging/Base.h>
+
+namespace facebook::react::bridging {
+
+template <
+    typename T,
+    typename C,
+    typename R,
+    typename... Args,
+    typename... JSArgs>
+T callFromJs(
+    jsi::Runtime &rt,
+    R (C::*method)(jsi::Runtime &, Args...),
+    const std::shared_ptr<CallInvoker> &jsInvoker,
+    C *instance,
+    JSArgs &&...args) {
+  static_assert(
+      sizeof...(Args) == sizeof...(JSArgs), "Incorrect arguments length");
+
+  if constexpr (std::is_void_v<T>) {
+    (instance->*method)(
+        rt, fromJs<Args>(rt, std::forward<JSArgs>(args), jsInvoker)...);
+
+  } else if constexpr (std::is_void_v<R>) {
+    static_assert(
+        std::is_same_v<T, jsi::Value>,
+        "Void functions may only return undefined");
+
+    (instance->*method)(
+        rt, fromJs<Args>(rt, std::forward<JSArgs>(args), jsInvoker)...);
+    return jsi::Value();
+
+  } else if constexpr (is_jsi_v<T>) {
+    return toJs(
+        rt,
+        (instance->*method)(
+            rt, fromJs<Args>(rt, std::forward<JSArgs>(args), jsInvoker)...),
+        jsInvoker);
+
+  } else {
+    return (instance->*method)(
+        rt, fromJs<Args>(rt, std::forward<JSArgs>(args), jsInvoker)...);
+  }
+}
+
+} // namespace facebook::react::bridging
diff --git a/ReactCommon/react/bridging/tests/ClassTest.cpp b/ReactCommon/react/bridging/tests/ClassTest.cpp
new file mode 100644
index 00000000000..06c37820fab
--- /dev/null
+++ b/ReactCommon/react/bridging/tests/ClassTest.cpp
@@ -0,0 +1,97 @@
+/*
+ * 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.
+ */
+
+#include "BridgingTest.h"
+
+namespace facebook::react {
+
+using namespace std::literals;
+
+struct TestClass {
+  TestClass(std::shared_ptr<CallInvoker> invoker) : invoker_(invoker) {}
+
+  double add(jsi::Runtime &, int a, float b) {
+    return a + b;
+  }
+
+  jsi::Object getObject(jsi::Runtime &, jsi::Object obj) {
+    return obj;
+  }
+
+  AsyncPromise<std::string> getPromise(jsi::Runtime &rt, std::string result) {
+    auto promise = AsyncPromise<std::string>(rt, invoker_);
+    promise.resolve(result);
+    return promise;
+  }
+
+  std::string
+  callFunc(jsi::Runtime &, SyncCallback<std::string(int)> func, int num) {
+    return func(num);
+  }
+
+  void callAsync(jsi::Runtime &, AsyncCallback<> callback) {
+    callback();
+  }
+
+ private:
+  std::shared_ptr<CallInvoker> invoker_;
+};
+
+TEST_F(BridgingTest, callFromJsTest) {
+  auto instance = TestClass(invoker);
+
+  EXPECT_EQ(
+      3.0,
+      bridging::callFromJs<double>(
+          rt, &TestClass::add, invoker, &instance, 1, 2.0));
+
+  auto object = jsi::Object(rt);
+
+  EXPECT_TRUE(jsi::Object::strictEquals(
+      rt,
+      object,
+      bridging::callFromJs<jsi::Object>(
+          rt, &TestClass::getObject, invoker, &instance, object)));
+
+  auto promise = bridging::callFromJs<jsi::Object>(
+      rt,
+      &TestClass::getPromise,
+      invoker,
+      &instance,
+      jsi::String::createFromAscii(rt, "hi"));
+  auto then = promise.getPropertyAsFunction(rt, "then");
+
+  std::string result;
+  then.callWithThis(
+      rt,
+      promise,
+      bridging::toJs(
+          rt, [&](std::string res) { result = res; }, invoker));
+
+  flushQueue();
+  EXPECT_EQ("hi"s, result);
+
+  auto func = function("(num) => String(num)");
+
+  EXPECT_EQ(
+      "1"s,
+      bridging::callFromJs<jsi::String>(
+          rt, &TestClass::callFunc, invoker, &instance, func, 1)
+          .utf8(rt));
+
+  bool called = false;
+  func = bridging::toJs(
+      rt, [&] { called = true; }, invoker);
+
+  bridging::callFromJs<void>(
+      rt, &TestClass::callAsync, invoker, &instance, func);
+
+  flushQueue();
+  EXPECT_TRUE(called);
+}
+
+} // namespace facebook::react