meta: combine enable_if_t and a meta policy detection utility to avoid API changes

src/entt/meta/factory.hpp

@@ -274,7 +274,7 @@ public:
             internal::meta_ctor_node{
                 descriptor::args_type::size,
                 &meta_arg<typename descriptor::args_type>,
-                &meta_construct<Type, Args...>});
+                static_cast<decltype(internal::meta_ctor_node::invoke)>(&meta_construct<Type, Args...>)});
 
         bucket = nullptr;
         return *this;

src/entt/meta/policy.hpp

@@ -61,6 +61,26 @@ struct as_void_t final {
      */
 };
 
+/**
+ * @brief Provides the member constant `value` to true if a type also is a meta
+ * policy, false otherwise.
+ * @tparam Type Type to check.
+ */
+template<typename Type>
+struct is_meta_policy
+    : std::disjunction<
+          std::is_same<Type, as_ref_t>,
+          std::is_same<Type, as_cref_t>,
+          std::is_same<Type, as_is_t>,
+          std::is_same<Type, as_void_t>> {};
+
+/**
+ * @brief Helper variable template.
+ * @tparam Type Type to check.
+ */
+template<typename Type>
+inline constexpr bool is_meta_policy_v = is_meta_policy<Type>::value;
+
 } // namespace entt
 
 #endif

src/entt/meta/utility.hpp

@@ -157,7 +157,7 @@ using meta_function_helper_t = typename meta_function_helper<Type, Candidate>::t
  * @return A meta any containing the returned value, if any.
  */
 template<typename Policy = as_is_t, typename Type>
-meta_any meta_dispatch(const meta_ctx &ctx, [[maybe_unused]] Type &&value) {
+std::enable_if_t<is_meta_policy_v<Policy>, meta_any> meta_dispatch(const meta_ctx &ctx, [[maybe_unused]] Type &&value) {
     if constexpr(std::is_same_v<Policy, as_void_t>) {
         return meta_any{ctx, std::in_place_type<void>};
     } else if constexpr(std::is_same_v<Policy, as_ref_t>) {
@@ -166,7 +166,6 @@ meta_any meta_dispatch(const meta_ctx &ctx, [[maybe_unused]] Type &&value) {
         static_assert(std::is_lvalue_reference_v<Type>, "Invalid type");
         return meta_any{ctx, std::in_place_type<const std::remove_reference_t<Type> &>, std::as_const(value)};
     } else {
-        static_assert(std::is_same_v<Policy, as_is_t>, "Policy not supported");
         return meta_any{ctx, std::forward<Type>(value)};
     }
 }
@@ -179,7 +178,7 @@ meta_any meta_dispatch(const meta_ctx &ctx, [[maybe_unused]] Type &&value) {
  * @return A meta any containing the returned value, if any.
  */
 template<typename Policy = as_is_t, typename Type>
-meta_any meta_dispatch(Type &&value) {
+std::enable_if_t<is_meta_policy_v<Policy>, meta_any> meta_dispatch(Type &&value) {
     return meta_dispatch<Policy, Type>(locator<meta_ctx>::value_or(), std::forward<Type>(value));
 }
 
@@ -260,7 +259,7 @@ template<typename Type, auto Data>
  * @return A meta any containing the value of the underlying variable.
  */
 template<typename Type, auto Data, typename Policy = as_is_t>
-[[nodiscard]] meta_any meta_getter(const meta_ctx &ctx, [[maybe_unused]] meta_handle instance) {
+[[nodiscard]] std::enable_if_t<is_meta_policy_v<Policy>, meta_any> meta_getter(const meta_ctx &ctx, [[maybe_unused]] meta_handle instance) {
     if constexpr(std::is_member_pointer_v<decltype(Data)> || std::is_function_v<std::remove_reference_t<std::remove_pointer_t<decltype(Data)>>>) {
         if constexpr(!std::is_array_v<std::remove_cv_t<std::remove_reference_t<std::invoke_result_t<decltype(Data), Type &>>>>) {
             if constexpr(std::is_invocable_v<decltype(Data), Type &>) {
@@ -297,7 +296,7 @@ template<typename Type, auto Data, typename Policy = as_is_t>
  * @return A meta any containing the value of the underlying variable.
  */
 template<typename Type, auto Data, typename Policy = as_is_t>
-[[nodiscard]] meta_any meta_getter(meta_handle instance) {
+[[nodiscard]] std::enable_if_t<is_meta_policy_v<Policy>, meta_any> meta_getter(meta_handle instance) {
     return meta_getter<Type, Data, Policy>(locator<meta_ctx>::value_or(), std::move(instance));
 }
 
@@ -319,7 +318,7 @@ template<typename Policy, typename Candidate, typename... Args>
 }
 
 template<typename Type, typename Policy, typename Candidate, std::size_t... Index>
-[[nodiscard]] meta_any meta_invoke(const meta_ctx &ctx, Candidate &&candidate, [[maybe_unused]] meta_handle instance, [[maybe_unused]] meta_any *args, std::index_sequence<Index...>) {
+[[nodiscard]] meta_any meta_invoke(const meta_ctx &ctx, [[maybe_unused]] meta_handle instance, Candidate &&candidate, [[maybe_unused]] meta_any *args, std::index_sequence<Index...>) {
     using descriptor = meta_function_helper_t<Type, std::remove_reference_t<Candidate>>;
 
     if constexpr(std::is_invocable_v<std::remove_reference_t<Candidate>, const Type &, type_list_element_t<Index, typename descriptor::args_type>...>) {
@@ -361,14 +360,14 @@ template<typename Type, typename... Args, std::size_t... Index>
  * @tparam Policy Optional policy (no policy set by default).
  * @param ctx The context from which to search for meta types.
  * @tparam Candidate The type of the actual object to _invoke_.
- * @param candidate The actual object to _invoke_.
  * @param instance An opaque instance of the underlying type, if required.
+ * @param candidate The actual object to _invoke_.
  * @param args Parameters to use to _invoke_ the object.
  * @return A meta any containing the returned value, if any.
  */
 template<typename Type, typename Policy = as_is_t, typename Candidate>
-[[nodiscard]] meta_any meta_invoke_with(const meta_ctx &ctx, Candidate &&candidate, meta_handle instance, meta_any *const args) {
-    return internal::meta_invoke<Type, Policy>(ctx, std::forward<Candidate>(candidate), std::move(instance), args, std::make_index_sequence<meta_function_helper_t<Type, std::remove_reference_t<Candidate>>::args_type::size>{});
+[[nodiscard]] std::enable_if_t<is_meta_policy_v<Policy>, meta_any> meta_invoke(const meta_ctx &ctx, meta_handle instance, Candidate &&candidate, meta_any *const args) {
+    return internal::meta_invoke<Type, Policy>(ctx, std::move(instance), std::forward<Candidate>(candidate), args, std::make_index_sequence<meta_function_helper_t<Type, std::remove_reference_t<Candidate>>::args_type::size>{});
 }
 
 /**
@@ -376,14 +375,14 @@ template<typename Type, typename Policy = as_is_t, typename Candidate>
  * @tparam Type Reflected type to which the object to _invoke_ is associated.
  * @tparam Policy Optional policy (no policy set by default).
  * @tparam Candidate The type of the actual object to _invoke_.
- * @param candidate The actual object to _invoke_.
  * @param instance An opaque instance of the underlying type, if required.
+ * @param candidate The actual object to _invoke_.
  * @param args Parameters to use to _invoke_ the object.
  * @return A meta any containing the returned value, if any.
  */
 template<typename Type, typename Policy = as_is_t, typename Candidate>
-[[nodiscard]] meta_any meta_invoke_with(Candidate &&candidate, meta_handle instance, meta_any *const args) {
-    return meta_invoke_with<Type, Policy>(locator<meta_ctx>::value_or(), std::forward<Candidate>(candidate), std::move(instance), args);
+[[nodiscard]] std::enable_if_t<is_meta_policy_v<Policy>, meta_any> meta_invoke(meta_handle instance, Candidate &&candidate, meta_any *const args) {
+    return meta_invoke<Type, Policy>(locator<meta_ctx>::value_or(), std::move(instance), std::forward<Candidate>(candidate), args);
 }
 
 /**
@@ -397,8 +396,8 @@ template<typename Type, typename Policy = as_is_t, typename Candidate>
  * @return A meta any containing the returned value, if any.
  */
 template<typename Type, auto Candidate, typename Policy = as_is_t>
-[[nodiscard]] meta_any meta_invoke(const meta_ctx &ctx, meta_handle instance, meta_any *const args) {
-    return internal::meta_invoke<Type, Policy>(ctx, Candidate, std::move(instance), args, std::make_index_sequence<meta_function_helper_t<Type, std::remove_reference_t<decltype(Candidate)>>::args_type::size>{});
+[[nodiscard]] std::enable_if_t<is_meta_policy_v<Policy>, meta_any> meta_invoke(const meta_ctx &ctx, meta_handle instance, meta_any *const args) {
+    return internal::meta_invoke<Type, Policy>(ctx, std::move(instance), Candidate, args, std::make_index_sequence<meta_function_helper_t<Type, std::remove_reference_t<decltype(Candidate)>>::args_type::size>{});
 }
 
 /**
@@ -411,7 +410,7 @@ template<typename Type, auto Candidate, typename Policy = as_is_t>
  * @return A meta any containing the returned value, if any.
  */
 template<typename Type, auto Candidate, typename Policy = as_is_t>
-[[nodiscard]] meta_any meta_invoke(meta_handle instance, meta_any *const args) {
+[[nodiscard]] std::enable_if_t<is_meta_policy_v<Policy>, meta_any> meta_invoke(meta_handle instance, meta_any *const args) {
     return meta_invoke<Type, Candidate, Policy>(locator<meta_ctx>::value_or(), std::move(instance), args);
 }
 
@@ -451,11 +450,11 @@ template<typename Type, typename... Args>
  * @return A meta any containing the returned value, if any.
  */
 template<typename Type, typename Policy = as_is_t, typename Candidate>
-[[nodiscard]] meta_any meta_construct_with(const meta_ctx &ctx, Candidate &&candidate, meta_any *const args) {
+[[nodiscard]] meta_any meta_construct(const meta_ctx &ctx, Candidate &&candidate, meta_any *const args) {
     if constexpr(meta_function_helper_t<Type, Candidate>::is_static || std::is_class_v<std::remove_cv_t<std::remove_reference_t<Candidate>>>) {
-        return internal::meta_invoke<Type, Policy>(ctx, std::forward<Candidate>(candidate), {}, args, std::make_index_sequence<meta_function_helper_t<Type, std::remove_reference_t<Candidate>>::args_type::size>{});
+        return internal::meta_invoke<Type, Policy>(ctx, {}, std::forward<Candidate>(candidate), args, std::make_index_sequence<meta_function_helper_t<Type, std::remove_reference_t<Candidate>>::args_type::size>{});
     } else {
-        return internal::meta_invoke<Type, Policy>(ctx, std::forward<Candidate>(candidate), *args, args + 1u, std::make_index_sequence<meta_function_helper_t<Type, std::remove_reference_t<Candidate>>::args_type::size>{});
+        return internal::meta_invoke<Type, Policy>(ctx, *args, std::forward<Candidate>(candidate), args + 1u, std::make_index_sequence<meta_function_helper_t<Type, std::remove_reference_t<Candidate>>::args_type::size>{});
     }
 }
 
@@ -469,8 +468,8 @@ template<typename Type, typename Policy = as_is_t, typename Candidate>
  * @return A meta any containing the returned value, if any.
  */
 template<typename Type, typename Policy = as_is_t, typename Candidate>
-[[nodiscard]] meta_any meta_construct_with(Candidate &&candidate, meta_any *const args) {
-    return meta_construct_with<Type, Policy>(locator<meta_ctx>::value_or(), std::forward<Candidate>(candidate), args);
+[[nodiscard]] std::enable_if_t<is_meta_policy_v<Policy>, meta_any> meta_construct(Candidate &&candidate, meta_any *const args) {
+    return meta_construct<Type, Policy>(locator<meta_ctx>::value_or(), std::forward<Candidate>(candidate), args);
 }
 
 /**
@@ -483,8 +482,8 @@ template<typename Type, typename Policy = as_is_t, typename Candidate>
  * @return A meta any containing the returned value, if any.
  */
 template<typename Type, auto Candidate, typename Policy = as_is_t>
-[[nodiscard]] meta_any meta_construct(const meta_ctx &ctx, meta_any *const args) {
-    return meta_construct_with<Type, Policy>(ctx, Candidate, args);
+[[nodiscard]] std::enable_if_t<is_meta_policy_v<Policy>, meta_any> meta_construct(const meta_ctx &ctx, meta_any *const args) {
+    return meta_construct<Type, Policy>(ctx, Candidate, args);
 }
 
 /**
@@ -496,7 +495,7 @@ template<typename Type, auto Candidate, typename Policy = as_is_t>
  * @return A meta any containing the returned value, if any.
  */
 template<typename Type, auto Candidate, typename Policy = as_is_t>
-[[nodiscard]] meta_any meta_construct(meta_any *const args) {
+[[nodiscard]] std::enable_if_t<is_meta_policy_v<Policy>, meta_any> meta_construct(meta_any *const args) {
     return meta_construct<Type, Candidate, Policy>(locator<meta_ctx>::value_or(), args);
 }
 

test/entt/meta/meta_utility.cpp

@@ -157,23 +157,23 @@ TEST_F(MetaUtility, MetaInvokeWithCandidate) {
     entt::meta_any args[2u]{clazz{}, 42};
     args[0u].cast<clazz &>().value = 99;
 
-    ASSERT_FALSE((entt::meta_invoke_with<clazz>(&clazz::setter, {}, nullptr)));
-    ASSERT_FALSE((entt::meta_invoke_with<clazz>(&clazz::getter, {}, nullptr)));
+    ASSERT_FALSE((entt::meta_invoke<clazz>({}, &clazz::setter, nullptr)));
+    ASSERT_FALSE((entt::meta_invoke<clazz>({}, &clazz::getter, nullptr)));
 
-    ASSERT_TRUE((entt::meta_invoke_with<clazz>(&clazz::setter, args[0u], args + 1u)));
-    ASSERT_FALSE((entt::meta_invoke_with<clazz>(&clazz::setter, args[0u], args)));
-    ASSERT_EQ((entt::meta_invoke_with<clazz>(&clazz::getter, args[0u], nullptr)).cast<int>(), 42);
-    ASSERT_FALSE((entt::meta_invoke_with<clazz>(&clazz::getter, args[1u], nullptr)));
+    ASSERT_TRUE((entt::meta_invoke<clazz>(args[0u], &clazz::setter, args + 1u)));
+    ASSERT_FALSE((entt::meta_invoke<clazz>(args[0u], &clazz::setter, args)));
+    ASSERT_EQ((entt::meta_invoke<clazz>(args[0u], &clazz::getter, nullptr)).cast<int>(), 42);
+    ASSERT_FALSE((entt::meta_invoke<clazz>(args[1u], &clazz::getter, nullptr)));
 
-    ASSERT_EQ((entt::meta_invoke_with<clazz>(&clazz::get_value, {}, nullptr)).cast<int>(), 99);
-    ASSERT_TRUE((entt::meta_invoke_with<clazz>(&clazz::reset_value, {}, nullptr)));
+    ASSERT_EQ((entt::meta_invoke<clazz>({}, &clazz::get_value, nullptr)).cast<int>(), 99);
+    ASSERT_TRUE((entt::meta_invoke<clazz>({}, &clazz::reset_value, nullptr)));
     ASSERT_EQ(args[0u].cast<clazz &>().value, 0);
 
     const auto setter = [](int &value) { value = 3; };
     const auto getter = [](int value) { return value * 2; };
 
-    ASSERT_TRUE(entt::meta_invoke_with<dummy>(setter, {}, args + 1u));
-    ASSERT_EQ(entt::meta_invoke_with<dummy>(getter, {}, args + 1u).cast<int>(), 6);
+    ASSERT_TRUE(entt::meta_invoke<dummy>({}, setter, args + 1u));
+    ASSERT_EQ(entt::meta_invoke<dummy>({}, getter, args + 1u).cast<int>(), 6);
 }
 
 TEST_F(MetaUtility, MetaInvoke) {
@@ -204,21 +204,21 @@ TEST_F(MetaUtility, MetaConstructArgsOnly) {
 
 TEST_F(MetaUtility, MetaConstructWithCandidate) {
     entt::meta_any args[2u]{clazz{}, 42};
-    const auto any = entt::meta_construct_with<clazz>(&clazz::factory, args + 1u);
+    const auto any = entt::meta_construct<clazz>(&clazz::factory, args + 1u);
 
     ASSERT_TRUE(any);
-    ASSERT_FALSE((entt::meta_construct_with<clazz>(&clazz::factory, args)));
+    ASSERT_FALSE((entt::meta_construct<clazz>(&clazz::factory, args)));
     ASSERT_EQ(any.cast<const clazz &>().member, 42);
 
     ASSERT_EQ(args[0u].cast<const clazz &>().member, 0);
-    ASSERT_TRUE((entt::meta_construct_with<clazz>(&clazz::static_setter, args)));
+    ASSERT_TRUE((entt::meta_construct<clazz>(&clazz::static_setter, args)));
     ASSERT_EQ(args[0u].cast<const clazz &>().member, 42);
 
     const auto setter = [](int &value) { value = 3; };
     const auto builder = [](int value) { return value * 2; };
 
-    ASSERT_TRUE(entt::meta_construct_with<dummy>(setter, args + 1u));
-    ASSERT_EQ(entt::meta_construct_with<dummy>(builder, args + 1u).cast<int>(), 6);
+    ASSERT_TRUE(entt::meta_construct<dummy>(setter, args + 1u));
+    ASSERT_EQ(entt::meta_construct<dummy>(builder, args + 1u).cast<int>(), 6);
 }
 
 TEST_F(MetaUtility, MetaConstruct) {