Facebook/react-native
1
0
Fork 0
mirror of https://github.com/facebook/react-native.git synced 2025-11-01 09:14:26 +00:00
Code Issues Packages Projects Releases Wiki Activity

Improve naming of template args in bridging (#51418)

Browse Source 
Summary:
Pull Request resolved: https://github.com/facebook/react-native/pull/51418

Improve readability

Changelog: [Internal]

Reviewed By: rshest

Differential Revision: D74884371

fbshipit-source-id: 26b6966458097c8ac8d030629a1bee131418a34d
This commit is contained in:
Pieter De Baets
2025-05-20 03:57:43 -07:00
committed by Facebook GitHub Bot
parent 5596923189
commit d6371bd6ac
2 changed files with 89 additions and 74 deletions
Download Patch File Download Diff File Expand all files Collapse all files
packages/react-native/ReactCommon/react/bridging/Base.h
+53 -42
View File
@@ -33,14 +33,14 @@ namespace detail {
template <typename F>
struct function_wrapper;
template <typename C, typename R, typename... Args>
struct function_wrapper<R (C::*)(Args...)> {
using type = std::function<R(Args...)>;
template <typename ClassT, typename ReturnT, typename... ArgsT>
struct function_wrapper<ReturnT (ClassT::*)(ArgsT...)> {
using type = std::function<ReturnT(ArgsT...)>;
};
template <typename C, typename R, typename... Args>
struct function_wrapper<R (C::*)(Args...) const> {
using type = std::function<R(Args...)>;
template <typename ClassT, typename ReturnT, typename... ArgsT>
struct function_wrapper<ReturnT (ClassT::*)(ArgsT...) const> {
using type = std::function<ReturnT(ArgsT...)>;
};
template <typename T, typename = void>
@@ -61,36 +61,47 @@ struct bridging_wrapper<
template <typename T>
using bridging_t = typename detail::bridging_wrapper<T>::type;
template <typename R, typename T, std::enable_if_t<is_jsi_v<T>, int> = 0>
auto fromJs(jsi::Runtime& rt, T&& value, const std::shared_ptr<CallInvoker>&)
-> decltype(static_cast<R>(
std::move(convert(rt, std::forward<T>(value))))) {
return static_cast<R>(std::move(convert(rt, std::forward<T>(value))));
}
template <typename R, typename T>
auto fromJs(jsi::Runtime& rt, T&& value, const std::shared_ptr<CallInvoker>&)
-> decltype(Bridging<remove_cvref_t<R>>::fromJs(
rt,
convert(rt, std::forward<T>(value)))) {
return Bridging<remove_cvref_t<R>>::fromJs(
rt, convert(rt, std::forward<T>(value)));
}
template <typename R, typename T>
template <typename ReturnT, typename JSArgT>
requires is_jsi_v<JSArgT>
auto fromJs(
jsi::Runtime& rt,
T&& value,
const std::shared_ptr<CallInvoker>& jsInvoker)
-> decltype(Bridging<remove_cvref_t<R>>::fromJs(
rt,
convert(rt, std::forward<T>(value)),
jsInvoker)) {
return Bridging<remove_cvref_t<R>>::fromJs(
rt, convert(rt, std::forward<T>(value)), jsInvoker);
JSArgT&& value,
const std::shared_ptr<CallInvoker>& /*unused*/)
-> decltype(static_cast<ReturnT>(
std::move(convert(rt, std::forward<JSArgT>(value)))))
{
return static_cast<ReturnT>(
std::move(convert(rt, std::forward<JSArgT>(value))));
}
template <typename T, std::enable_if_t<is_jsi_v<T>, int> = 0>
template <typename ReturnT, typename JSArgT>
auto fromJs(
jsi::Runtime& rt,
JSArgT&& value,
const std::shared_ptr<CallInvoker>& /*unused*/)
-> decltype(Bridging<remove_cvref_t<ReturnT>>::fromJs(
rt,
convert(rt, std::forward<JSArgT>(value)))) {
return Bridging<remove_cvref_t<ReturnT>>::fromJs(
rt, convert(rt, std::forward<JSArgT>(value)));
}
template <typename ReturnT, typename JSArgT>
auto fromJs(
jsi::Runtime& rt,
JSArgT&& value,
const std::shared_ptr<CallInvoker>& jsInvoker)
-> decltype(Bridging<remove_cvref_t<ReturnT>>::fromJs(
rt,
convert(rt, std::forward<JSArgT>(value)),
jsInvoker)) {
return Bridging<remove_cvref_t<ReturnT>>::fromJs(
rt, convert(rt, std::forward<JSArgT>(value)), jsInvoker);
}
template <typename T>
requires is_jsi_v<T>
auto toJs(
jsi::Runtime& rt,
T&& value,
@@ -143,33 +154,33 @@ inline constexpr bool supportsFromJs<
template <typename, typename = jsi::Value, typename = void>
inline constexpr bool supportsToJs = false;
template <typename T, typename Ret>
template <typename JSReturnT, typename ReturnT>
inline constexpr bool supportsToJs<
T,
Ret,
JSReturnT,
ReturnT,
std::void_t<decltype(toJs(
std::declval<jsi::Runtime&>(),
std::declval<T>(),
std::declval<JSReturnT>(),
nullptr))>> =
std::is_convertible_v<
decltype(toJs(
std::declval<jsi::Runtime&>(),
std::declval<T>(),
std::declval<JSReturnT>(),
nullptr)),
Ret>;
ReturnT>;
template <typename T>
template <typename ReturnT>
inline constexpr bool supportsToJs<
T,
ReturnT,
jsi::Value,
std::void_t<decltype(toJs(
std::declval<jsi::Runtime&>(),
std::declval<T>(),
std::declval<ReturnT>(),
nullptr))>> =
std::is_convertible_v<
decltype(toJs(
std::declval<jsi::Runtime&>(),
std::declval<T>(),
std::declval<ReturnT>(),
nullptr)),
jsi::Value>;
packages/react-native/ReactCommon/react/bridging/Class.h
+36 -32
View File
@@ -12,54 +12,57 @@
namespace facebook::react::bridging {
template <
typename T,
typename C,
typename R,
typename... Args,
typename... JSArgs>
T callFromJs(
typename JSReturnT,
typename ClassT,
typename ReturnT,
typename... ArgsT,
typename... JSArgsT>
JSReturnT callFromJs(
jsi::Runtime& rt,
R (C::*method)(jsi::Runtime&, Args...),
ReturnT (ClassT::*method)(jsi::Runtime&, ArgsT...),
const std::shared_ptr<CallInvoker>& jsInvoker,
C* instance,
JSArgs&&... args) {
ClassT* instance,
JSArgsT&&... args) {
static_assert(
sizeof...(Args) == sizeof...(JSArgs), "Incorrect arguments length");
sizeof...(ArgsT) == sizeof...(JSArgsT), "Incorrect arguments length");
static_assert(
(supportsFromJs<Args, JSArgs> && ...), "Incompatible arguments");
(supportsFromJs<ArgsT, JSArgsT> && ...), "Incompatible arguments");
if constexpr (std::is_void_v<T>) {
if constexpr (std::is_void_v<JSReturnT>) {
(instance->*method)(
rt, fromJs<Args>(rt, std::forward<JSArgs>(args), jsInvoker)...);
rt, fromJs<ArgsT>(rt, std::forward<JSArgsT>(args), jsInvoker)...);
} else if constexpr (std::is_void_v<R>) {
} else if constexpr (std::is_void_v<ReturnT>) {
static_assert(
std::is_same_v<T, jsi::Value>,
std::is_same_v<JSReturnT, jsi::Value>,
"Void functions may only return undefined");
(instance->*method)(
rt, fromJs<Args>(rt, std::forward<JSArgs>(args), jsInvoker)...);
rt, fromJs<ArgsT>(rt, std::forward<JSArgsT>(args), jsInvoker)...);
return jsi::Value();
} else if constexpr (is_jsi_v<T> || supportsToJs<R, T>) {
static_assert(supportsToJs<R, T>, "Incompatible return type");
} else if constexpr (
is_jsi_v<JSReturnT> || supportsToJs<ReturnT, JSReturnT>) {
static_assert(supportsToJs<ReturnT, JSReturnT>, "Incompatible return type");
return toJs(
rt,
(instance->*method)(
rt, fromJs<Args>(rt, std::forward<JSArgs>(args), jsInvoker)...),
rt, fromJs<ArgsT>(rt, std::forward<JSArgsT>(args), jsInvoker)...),
jsInvoker);
} else if constexpr (is_optional_jsi_v<T>) {
} else if constexpr (is_optional_jsi_v<JSReturnT>) {
static_assert(
is_optional_v<R>
? supportsToJs<typename R::value_type, typename T::value_type>
: supportsToJs<R, typename T::value_type>,
is_optional_v<ReturnT>
? supportsToJs<
typename ReturnT::value_type,
typename JSReturnT::value_type>
: supportsToJs<ReturnT, typename JSReturnT::value_type>,
"Incompatible return type");
auto result = toJs(
rt,
(instance->*method)(
rt, fromJs<Args>(rt, std::forward<JSArgs>(args), jsInvoker)...),
rt, fromJs<ArgsT>(rt, std::forward<JSArgsT>(args), jsInvoker)...),
jsInvoker);
if constexpr (std::is_same_v<decltype(result), jsi::Value>) {
@@ -70,20 +73,21 @@ T callFromJs(
return convert(rt, std::move(result));
} else {
static_assert(std::is_convertible_v<R, T>, "Incompatible return type");
static_assert(
std::is_convertible_v<ReturnT, JSReturnT>, "Incompatible return type");
return (instance->*method)(
rt, fromJs<Args>(rt, std::forward<JSArgs>(args), jsInvoker)...);
rt, fromJs<ArgsT>(rt, std::forward<JSArgsT>(args), jsInvoker)...);
}
}
template <typename R, typename... Args>
constexpr size_t getParameterCount(R (*)(Args...)) {
return sizeof...(Args);
template <typename ReturnT, typename... ArgsT>
constexpr size_t getParameterCount(ReturnT (*)(ArgsT...)) {
return sizeof...(ArgsT);
}
template <typename C, typename R, typename... Args>
constexpr size_t getParameterCount(R (C::*)(Args...)) {
return sizeof...(Args);
template <typename Class, typename ReturnT, typename... ArgsT>
constexpr size_t getParameterCount(ReturnT (Class::*)(ArgsT...)) {
return sizeof...(ArgsT);
}
} // namespace facebook::react::bridging