meta: reintroduce arity and arg index on meta_data

src/entt/meta/factory.hpp

@@ -385,8 +385,9 @@ public:
                     name,
                     /* this is never static */
                     stl::is_const_v<stl::remove_reference_t<data_type>> ? internal::meta_traits::is_const : internal::meta_traits::is_none,
+                    1u,
                     &internal::resolve<stl::remove_cvref_t<data_type>>,
-                    &internal::resolve<stl::remove_cvref_t<data_type>>,
+                    &meta_arg<type_list<stl::remove_cvref_t<data_type>>>,
                     &meta_setter<element_type, Data>,
                     &meta_getter<element_type, Data, Policy>});
         } else {
@@ -403,8 +404,9 @@ public:
                     id,
                     name,
                     ((!stl::is_pointer_v<decltype(Data)> || stl::is_const_v<data_type>) ? internal::meta_traits::is_const : internal::meta_traits::is_none) | internal::meta_traits::is_static,
+                    1u,
                     &internal::resolve<stl::remove_cvref_t<data_type>>,
-                    &internal::resolve<stl::remove_cvref_t<data_type>>,
+                    &meta_arg<type_list<stl::remove_cvref_t<data_type>>>,
                     &meta_setter<element_type, Data>,
                     &meta_getter<element_type, Data, Policy>});
         }
@@ -459,8 +461,9 @@ public:
                     name,
                     /* this is never static */
                     internal::meta_traits::is_const,
+                    0u,
                     &internal::resolve<stl::remove_cvref_t<typename descriptor::return_type>>,
-                    nullptr,
+                    &meta_arg<type_list<>>,
                     &meta_setter<element_type, Setter>,
                     &meta_getter<element_type, Getter, Policy>});
         } else {
@@ -472,8 +475,9 @@ public:
                     name,
                     /* this is never static nor const */
                     internal::meta_traits::is_none,
+                    1u,
                     &internal::resolve<stl::remove_cvref_t<typename descriptor::return_type>>,
-                    &internal::resolve<stl::remove_cvref_t<type_list_element_t<static_cast<stl::size_t>(args_type::size != 1u), args_type>>>,
+                    &meta_arg<type_list<type_list_element_t<static_cast<stl::size_t>(args_type::size != 1u), args_type>>>,
                     &meta_setter<element_type, Setter>,
                     &meta_getter<element_type, Getter, Policy>});
         }

src/entt/meta/meta.hpp

@@ -838,6 +838,14 @@ struct meta_data: meta_object<internal::meta_data_node> {
         return (node_or_assert().name == nullptr) ? stl::string_view{} : stl::string_view{node_or_assert().name};
     }
 
+    /**
+     * @brief Returns the number of arguments accepted by a data member.
+     * @return The number of arguments accepted by the data member.
+     */
+    [[nodiscard]] size_type arity() const noexcept {
+        return node_or_assert().arity;
+    }
+
     /**
      * @brief Indicates whether a data member is constant or not.
      * @return True if the data member is constant, false otherwise.
@@ -882,10 +890,11 @@ struct meta_data: meta_object<internal::meta_data_node> {
     }
 
     /**
-     * @brief Returns the type of the argument of a data member.
-     * @return The type of the argument of a data member.
+     * @brief Returns the type of the i-th argument of a data member.
+     * @param index Index of the argument of which to return the type.
+     * @return The type of the i-th argument of a data member.
      */
-    [[nodiscard]] inline meta_type arg() const noexcept;
+    [[nodiscard]] inline meta_type arg(size_type index) const noexcept;
 
     /**
      * @brief Returns all meta traits for a given meta object.
@@ -1561,8 +1570,8 @@ inline bool meta_any::assign(meta_any &&other) {
     return meta_type{*ctx, node_or_assert().type(internal::meta_context::from(*ctx))};
 }
 
-[[nodiscard]] inline meta_type meta_data::arg() const noexcept {
-    return (node_or_assert().arg == nullptr) ? meta_type{} : meta_type{*ctx, node_or_assert().arg(internal::meta_context::from(*ctx))};
+[[nodiscard]] inline meta_type meta_data::arg(const size_type index) const noexcept {
+    return index < arity() ? node_or_assert().arg(*ctx, index) : meta_type{};
 }
 
 [[nodiscard]] inline meta_type meta_func::ret() const noexcept {

src/entt/meta/node.hpp

@@ -93,8 +93,9 @@ struct meta_data_node {
     id_type id{};
     const char *name{};
     meta_traits traits{meta_traits::is_none};
+    size_type arity{0u};
     const meta_type_node &(*type)(const meta_context &) noexcept {};
-    const meta_type_node &(*arg)(const meta_context &) noexcept {};
+    meta_type (*arg)(const meta_ctx &, const size_type) noexcept {};
     bool (*set)(meta_handle, meta_any){};
     meta_any (*get)(meta_handle){};
     meta_custom_node custom{};

test/entt/meta/meta_context.cpp

@@ -278,8 +278,8 @@ TEST_F(MetaContext, MetaData) {
     ASSERT_EQ(global.data("value"_hs).type().data("marker"_hs).get({}).cast<int>(), global_marker);
     ASSERT_EQ(local.data("value"_hs).type().data("marker"_hs).get({}).cast<int>(), local_marker);
 
-    ASSERT_EQ(global.data("rw"_hs).arg().data("marker"_hs).get({}).cast<int>(), global_marker);
-    ASSERT_EQ(local.data("rw"_hs).arg().data("marker"_hs).get({}).cast<int>(), local_marker);
+    ASSERT_EQ(global.data("rw"_hs).arg(0u).data("marker"_hs).get({}).cast<int>(), global_marker);
+    ASSERT_EQ(local.data("rw"_hs).arg(0u).data("marker"_hs).get({}).cast<int>(), local_marker);
 
     clazz instance{'c', 8};
     const argument value{2};

test/entt/meta/meta_data.cpp

@@ -199,8 +199,9 @@ TEST_F(MetaData, NonConst) {
     clazz instance{};
 
     ASSERT_TRUE(data);
+    ASSERT_EQ(data.arity(), 1u);
     ASSERT_EQ(data.type(), entt::resolve<int>());
-    ASSERT_EQ(data.arg(), entt::resolve<int>());
+    ASSERT_EQ(data.arg(0u), entt::resolve<int>());
     ASSERT_FALSE(data.is_const());
     ASSERT_FALSE(data.is_static());
     ASSERT_EQ(data.get(instance).cast<int>(), 0);
@@ -215,8 +216,9 @@ TEST_F(MetaData, Const) {
     clazz instance{};
 
     ASSERT_TRUE(data);
+    ASSERT_EQ(data.arity(), 1u);
     ASSERT_EQ(data.type(), entt::resolve<int>());
-    ASSERT_EQ(data.arg(), entt::resolve<int>());
+    ASSERT_EQ(data.arg(0u), entt::resolve<int>());
     ASSERT_TRUE(data.is_const());
     ASSERT_FALSE(data.is_static());
     ASSERT_EQ(data.get(instance).cast<int>(), 1);
@@ -230,8 +232,9 @@ TEST_F(MetaData, Static) {
     auto data = entt::resolve<clazz>().data("h"_hs);
 
     ASSERT_TRUE(data);
+    ASSERT_EQ(data.arity(), 1u);
     ASSERT_EQ(data.type(), entt::resolve<int>());
-    ASSERT_EQ(data.arg(), entt::resolve<int>());
+    ASSERT_EQ(data.arg(0u), entt::resolve<int>());
     ASSERT_FALSE(data.is_const());
     ASSERT_TRUE(data.is_static());
     ASSERT_EQ(data.get({}).cast<int>(), 2);
@@ -245,8 +248,9 @@ TEST_F(MetaData, ConstStatic) {
     auto data = entt::resolve<clazz>().data("k"_hs);
 
     ASSERT_TRUE(data);
+    ASSERT_EQ(data.arity(), 1u);
     ASSERT_EQ(data.type(), entt::resolve<int>());
-    ASSERT_EQ(data.arg(), entt::resolve<int>());
+    ASSERT_EQ(data.arg(0u), entt::resolve<int>());
     ASSERT_TRUE(data.is_const());
     ASSERT_TRUE(data.is_static());
     ASSERT_EQ(data.get({}).cast<int>(), 3);
@@ -260,8 +264,9 @@ TEST_F(MetaData, Literal) {
     auto data = entt::resolve<clazz>().data("l"_hs);
 
     ASSERT_TRUE(data);
+    ASSERT_EQ(data.arity(), 1u);
     ASSERT_EQ(data.type(), entt::resolve<char>());
-    ASSERT_EQ(data.arg(), entt::resolve<char>());
+    ASSERT_EQ(data.arg(0u), entt::resolve<char>());
     ASSERT_TRUE(data.is_const());
     ASSERT_TRUE(data.is_static());
     ASSERT_EQ(data.get({}).cast<char>(), 'c');
@@ -370,8 +375,9 @@ TEST_F(MetaData, SetterGetterAsFreeFunctions) {
     setter_getter instance{};
 
     ASSERT_TRUE(data);
+    ASSERT_EQ(data.arity(), 1u);
     ASSERT_EQ(data.type(), entt::resolve<int>());
-    ASSERT_EQ(data.arg(), entt::resolve<int>());
+    ASSERT_EQ(data.arg(0u), entt::resolve<int>());
     ASSERT_FALSE(data.is_const());
     ASSERT_FALSE(data.is_static());
     ASSERT_EQ(data.get(instance).cast<int>(), 0);
@@ -386,8 +392,9 @@ TEST_F(MetaData, SetterGetterAsMemberFunctions) {
     setter_getter instance{};
 
     ASSERT_TRUE(data);
+    ASSERT_EQ(data.arity(), 1u);
     ASSERT_EQ(data.type(), entt::resolve<int>());
-    ASSERT_EQ(data.arg(), entt::resolve<double>());
+    ASSERT_EQ(data.arg(0u), entt::resolve<double>());
     ASSERT_FALSE(data.is_const());
     ASSERT_FALSE(data.is_static());
     ASSERT_EQ(data.get(instance).cast<int>(), 0);
@@ -404,8 +411,9 @@ TEST_F(MetaData, SetterGetterWithRefAsMemberFunctions) {
     setter_getter instance{};
 
     ASSERT_TRUE(data);
+    ASSERT_EQ(data.arity(), 1u);
     ASSERT_EQ(data.type(), entt::resolve<int>());
-    ASSERT_EQ(data.arg(), entt::resolve<int>());
+    ASSERT_EQ(data.arg(0u), entt::resolve<int>());
     ASSERT_FALSE(data.is_const());
     ASSERT_FALSE(data.is_static());
     ASSERT_EQ(data.get(instance).cast<int>(), 0);
@@ -420,8 +428,9 @@ TEST_F(MetaData, SetterGetterMixed) {
     setter_getter instance{};
 
     ASSERT_TRUE(data);
+    ASSERT_EQ(data.arity(), 1u);
     ASSERT_EQ(data.type(), entt::resolve<int>());
-    ASSERT_EQ(data.arg(), entt::resolve<int>());
+    ASSERT_EQ(data.arg(0u), entt::resolve<int>());
     ASSERT_FALSE(data.is_const());
     ASSERT_FALSE(data.is_static());
     ASSERT_EQ(data.get(instance).cast<int>(), 0);
@@ -436,8 +445,9 @@ TEST_F(MetaData, SetterGetterReadOnly) {
     setter_getter instance{};
 
     ASSERT_TRUE(data);
+    ASSERT_EQ(data.arity(), 0u);
     ASSERT_EQ(data.type(), entt::resolve<int>());
-    ASSERT_EQ(data.arg(), entt::meta_type{});
+    ASSERT_EQ(data.arg(0u), entt::meta_type{});
     ASSERT_TRUE(data.is_const());
     ASSERT_FALSE(data.is_static());
     ASSERT_EQ(data.get(instance).cast<int>(), 0);
@@ -452,8 +462,9 @@ TEST_F(MetaData, SetterGetterReadOnlyDataMember) {
     setter_getter instance{};
 
     ASSERT_TRUE(data);
+    ASSERT_EQ(data.arity(), 0u);
     ASSERT_EQ(data.type(), entt::resolve<int>());
-    ASSERT_EQ(data.arg(), entt::meta_type{});
+    ASSERT_EQ(data.arg(0u), entt::meta_type{});
     ASSERT_TRUE(data.is_const());
     ASSERT_FALSE(data.is_static());
     ASSERT_EQ(data.get(instance).cast<int>(), 0);
@@ -494,9 +505,10 @@ TEST_F(MetaData, ArrayStatic) {
     auto data = entt::resolve<array>().data("global"_hs);
 
     ASSERT_TRUE(data);
+    ASSERT_EQ(data.arity(), 1u);
     // NOLINTBEGIN(*-avoid-c-arrays)
     ASSERT_EQ(data.type(), entt::resolve<int[2]>());
-    ASSERT_EQ(data.arg(), entt::resolve<int[2]>());
+    ASSERT_EQ(data.arg(0u), entt::resolve<int[2]>());
     // NOLINTEND(*-avoid-c-arrays)
     ASSERT_FALSE(data.is_const());
     ASSERT_TRUE(data.is_static());
@@ -511,9 +523,10 @@ TEST_F(MetaData, Array) {
     array instance{};
 
     ASSERT_TRUE(data);
+    ASSERT_EQ(data.arity(), 1u);
     // NOLINTBEGIN(*-avoid-c-arrays)
     ASSERT_EQ(data.type(), entt::resolve<int[4]>());
-    ASSERT_EQ(data.arg(), entt::resolve<int[4]>());
+    ASSERT_EQ(data.arg(0u), entt::resolve<int[4]>());
     // NOLINTEND(*-avoid-c-arrays)
     ASSERT_FALSE(data.is_const());
     ASSERT_FALSE(data.is_static());
@@ -528,8 +541,9 @@ TEST_F(MetaData, AsVoid) {
     clazz instance{};
 
     ASSERT_TRUE(data);
+    ASSERT_EQ(data.arity(), 1u);
     ASSERT_EQ(data.type(), entt::resolve<int>());
-    ASSERT_EQ(data.arg(), entt::resolve<int>());
+    ASSERT_EQ(data.arg(0u), entt::resolve<int>());
     ASSERT_TRUE(data.set(instance, 1));
     ASSERT_EQ(instance.i, 1);
     ASSERT_EQ(data.get(instance), entt::meta_any{std::in_place_type<void>});
@@ -580,8 +594,9 @@ TEST_F(MetaData, AsRef) {
     auto data = entt::resolve<clazz>().data("i"_hs);
 
     ASSERT_TRUE(data);
+    ASSERT_EQ(data.arity(), 1u);
     ASSERT_EQ(data.type(), entt::resolve<int>());
-    ASSERT_EQ(data.arg(), entt::resolve<int>());
+    ASSERT_EQ(data.arg(0u), entt::resolve<int>());
     ASSERT_EQ(instance.i, 0);
 
     data.get(instance).cast<int &>() = 3;
@@ -596,8 +611,9 @@ TEST_F(MetaData, AsConstRef) {
     auto data = entt::resolve<clazz>().data("ci"_hs);
 
     ASSERT_EQ(instance.i, 0);
+    ASSERT_EQ(data.arity(), 1u);
     ASSERT_EQ(data.type(), entt::resolve<int>());
-    ASSERT_EQ(data.arg(), entt::resolve<int>());
+    ASSERT_EQ(data.arg(0u), entt::resolve<int>());
     ASSERT_EQ(data.get(instance).cast<const int &>(), 0);
     ASSERT_EQ(data.get(instance).cast<int>(), 0);
     ASSERT_EQ(instance.i, 0);