meta: reintroduce meta_type::is_array support

src/entt/meta/meta.hpp

@@ -1107,6 +1107,14 @@ public:
         return !!(node->traits & internal::meta_traits::IS_ARITHMETIC);
     }
 
+    /**
+     * @brief Checks whether a type refers to an array type or not.
+     * @return True if the underlying type is an array type, false otherwise.
+     */
+    [[nodiscard]] bool is_array() const ENTT_NOEXCEPT {
+        return !!(node->traits & internal::meta_traits::IS_ARRAY);
+    }
+
     /**
      * @brief Checks whether a type refers to an enum or not.
      * @return True if the underlying type is an enum, false otherwise.

src/entt/meta/node.hpp

@@ -36,12 +36,13 @@ enum class meta_traits: std::uint32_t {
     IS_CONST = 0x0001,
     IS_STATIC = 0x0002,
     IS_ARITHMETIC = 0x0004,
-    IS_ENUM = 0x0008,
-    IS_CLASS = 0x0010,
-    IS_POINTER = 0x0020,
-    IS_META_POINTER_LIKE = 0x0100,
-    IS_META_SEQUENCE_CONTAINER = 0x0200,
-    IS_META_ASSOCIATIVE_CONTAINER = 0x0400,
+    IS_ARRAY = 0x0008,
+    IS_ENUM = 0x0010,
+    IS_CLASS = 0x0020,
+    IS_POINTER = 0x0040,
+    IS_META_POINTER_LIKE = 0x0080,
+    IS_META_SEQUENCE_CONTAINER = 0x0100,
+    IS_META_ASSOCIATIVE_CONTAINER = 0x0200,
     _entt_enum_as_bitmask
 };
 
@@ -173,6 +174,7 @@ public:
             size_of_v<Type>,
             internal::meta_traits::IS_NONE
                 | (std::is_arithmetic_v<Type> ? internal::meta_traits::IS_ARITHMETIC : internal::meta_traits::IS_NONE)
+                | (std::is_array_v<Type> ? internal::meta_traits::IS_ARRAY : internal::meta_traits::IS_NONE)
                 | (std::is_enum_v<Type> ? internal::meta_traits::IS_ENUM : internal::meta_traits::IS_NONE)
                 | (std::is_class_v<Type> ? internal::meta_traits::IS_CLASS : internal::meta_traits::IS_NONE)
                 | (std::is_pointer_v<Type> ? internal::meta_traits::IS_POINTER : internal::meta_traits::IS_NONE)

test/entt/meta/meta_data.cpp

@@ -63,6 +63,11 @@ struct setter_getter_t {
     int value;
 };
 
+struct array_t {
+    static inline int global[3];
+    int local[5];
+};
+
 enum class property_t {
     random,
     value
@@ -105,6 +110,11 @@ struct MetaData: ::testing::Test {
             .data<nullptr, &setter_getter_t::getter>("z_ro"_hs)
             .data<nullptr, &setter_getter_t::value>("value"_hs);
 
+        entt::meta<array_t>()
+            .type("array"_hs)
+            .data<&array_t::global>("global"_hs)
+            .data<&array_t::local>("local"_hs);
+
         base_t::counter = 0;
     }
 
@@ -444,6 +454,35 @@ TEST_F(MetaData, ConstInstance) {
     ASSERT_FALSE(entt::resolve<clazz_t>().data("j"_hs).set(std::as_const(instance), 3));
 }
 
+TEST_F(MetaData, ArrayStatic) {
+    using namespace entt::literals;
+
+    auto data = entt::resolve<array_t>().data("global"_hs);
+
+    ASSERT_TRUE(data);
+    ASSERT_EQ(data.type(), entt::resolve<int[3]>());
+    ASSERT_EQ(data.id(), "global"_hs);
+    ASSERT_FALSE(data.is_const());
+    ASSERT_TRUE(data.is_static());
+    ASSERT_TRUE(data.type().is_array());
+    ASSERT_FALSE(data.get({}));
+}
+
+TEST_F(MetaData, Array) {
+    using namespace entt::literals;
+
+    auto data = entt::resolve<array_t>().data("local"_hs);
+    array_t instance{};
+
+    ASSERT_TRUE(data);
+    ASSERT_EQ(data.type(), entt::resolve<int[5]>());
+    ASSERT_EQ(data.id(), "local"_hs);
+    ASSERT_FALSE(data.is_const());
+    ASSERT_FALSE(data.is_static());
+    ASSERT_TRUE(data.type().is_array());
+    ASSERT_FALSE(data.get(instance));
+}
+
 TEST_F(MetaData, AsVoid) {
     using namespace entt::literals;
 

test/entt/meta/meta_type.cpp

@@ -214,6 +214,10 @@ TEST_F(MetaType, Traits) {
     ASSERT_TRUE(entt::resolve<double>().is_arithmetic());
     ASSERT_FALSE(entt::resolve<clazz_t>().is_arithmetic());
 
+    ASSERT_TRUE(entt::resolve<int[5]>().is_array());
+    ASSERT_TRUE(entt::resolve<int[5][3]>().is_array());
+    ASSERT_FALSE(entt::resolve<int>().is_array());
+
     ASSERT_TRUE(entt::resolve<property_t>().is_enum());
     ASSERT_FALSE(entt::resolve<char>().is_enum());