test: avoid _t types

test/entt/core/compressed_pair.cpp

@@ -10,15 +10,10 @@
 #include <entt/core/compressed_pair.hpp>
 
 TEST(CompressedPair, Size) {
-    struct local {
-        int value;
-        test::empty empty;
-    };
-
     ASSERT_EQ(sizeof(entt::compressed_pair<int, int>), sizeof(int) * 2u);
     ASSERT_EQ(sizeof(entt::compressed_pair<test::empty, int>), sizeof(int));
     ASSERT_EQ(sizeof(entt::compressed_pair<int, test::empty>), sizeof(int));
-    ASSERT_LT(sizeof(entt::compressed_pair<int, test::empty>), sizeof(local));
+    ASSERT_LT(sizeof(entt::compressed_pair<int, test::empty>), sizeof(std::tuple<int, test::empty>));
     ASSERT_LT(sizeof(entt::compressed_pair<int, test::empty>), sizeof(std::pair<int, test::empty>));
 }
 

test/entt/meta/meta_any.cpp

@@ -12,7 +12,7 @@
 #include <entt/meta/meta.hpp>
 #include <entt/meta/resolve.hpp>
 
-struct clazz_t {
+struct clazz {
     void member(int i) {
         value = i;
     }
@@ -29,17 +29,17 @@ struct clazz_t {
     int value{0};
 };
 
-struct empty_t {
-    empty_t() = default;
+struct empty {
+    empty() = default;
 
-    empty_t(const empty_t &) = default;
-    empty_t &operator=(const empty_t &) = default;
+    empty(const empty &) = default;
+    empty &operator=(const empty &) = default;
 
-    virtual ~empty_t() {
+    virtual ~empty() {
         ++destructor_counter;
     }
 
-    static void destroy(empty_t &) {
+    static void destroy(empty &) {
         ++destroy_counter;
     }
 
@@ -47,19 +47,19 @@ struct empty_t {
     inline static int destructor_counter = 0; // NOLINT
 };
 
-struct fat_t: empty_t {
-    fat_t()
+struct fat: empty {
+    fat()
         : value{.0, .0, .0, .0} {}
 
-    fat_t(double v1, double v2, double v3, double v4)
+    fat(double v1, double v2, double v3, double v4)
         : value{v1, v2, v3, v4} {}
 
-    ~fat_t() override = default;
+    ~fat() override = default;
 
-    fat_t(const fat_t &) = default;
-    fat_t &operator=(const fat_t &) = default;
+    fat(const fat &) = default;
+    fat &operator=(const fat &) = default;
 
-    bool operator==(const fat_t &other) const {
+    bool operator==(const fat &other) const {
         return (value == other.value);
     }
 
@@ -71,17 +71,17 @@ enum class enum_class : unsigned short int {
     bar = 1u
 };
 
-struct unmanageable_t {
-    unmanageable_t()
+struct unmanageable {
+    unmanageable()
         : value{std::make_unique<int>(3)} {}
 
-    ~unmanageable_t() = default;
+    ~unmanageable() = default;
 
-    unmanageable_t(const unmanageable_t &) = delete;
-    unmanageable_t(unmanageable_t &&) = delete;
+    unmanageable(const unmanageable &) = delete;
+    unmanageable(unmanageable &&) = delete;
 
-    unmanageable_t &operator=(const unmanageable_t &) = delete;
-    unmanageable_t &operator=(unmanageable_t &&) = delete;
+    unmanageable &operator=(const unmanageable &) = delete;
+    unmanageable &operator=(unmanageable &&) = delete;
 
     std::unique_ptr<int> value;
 };
@@ -90,24 +90,24 @@ struct MetaAny: ::testing::Test {
     void SetUp() override {
         using namespace entt::literals;
 
-        entt::meta<empty_t>()
+        entt::meta<empty>()
             .type("empty"_hs)
-            .dtor<empty_t::destroy>();
+            .dtor<empty::destroy>();
 
-        entt::meta<fat_t>()
+        entt::meta<fat>()
             .type("fat"_hs)
-            .base<empty_t>()
-            .dtor<fat_t::destroy>();
+            .base<empty>()
+            .dtor<fat::destroy>();
 
-        entt::meta<clazz_t>()
+        entt::meta<clazz>()
             .type("clazz"_hs)
-            .data<&clazz_t::value>("value"_hs)
-            .func<&clazz_t::member>("member"_hs)
-            .func<clazz_t::func>("func"_hs)
+            .data<&clazz::value>("value"_hs)
+            .func<&clazz::member>("member"_hs)
+            .func<clazz::func>("func"_hs)
             .conv<int>();
 
-        empty_t::destroy_counter = 0;
-        empty_t::destructor_counter = 0;
+        empty::destroy_counter = 0;
+        empty::destructor_counter = 0;
     }
 
     void TearDown() override {
@@ -130,16 +130,16 @@ TEST_F(MetaAny, SBO) {
 }
 
 TEST_F(MetaAny, NoSBO) {
-    const fat_t instance{.1, .2, .3, .4};
+    const fat instance{.1, .2, .3, .4};
     entt::meta_any any{instance};
 
     ASSERT_TRUE(any);
     ASSERT_EQ(any.policy(), entt::meta_any_policy::owner);
     ASSERT_FALSE(any.try_cast<std::size_t>());
-    ASSERT_EQ(any.cast<fat_t>(), instance);
+    ASSERT_EQ(any.cast<fat>(), instance);
     ASSERT_NE(any.data(), nullptr);
     ASSERT_EQ(any, entt::meta_any{instance});
-    ASSERT_NE(any, fat_t{});
+    ASSERT_NE(any, fat{});
 }
 
 TEST_F(MetaAny, Empty) {
@@ -320,7 +320,7 @@ TEST_F(MetaAny, SBODirectAssignment) {
 TEST_F(MetaAny, SBOAssignValue) {
     entt::meta_any any{3};
     const entt::meta_any other{1};
-    const entt::meta_any invalid{empty_t{}};
+    const entt::meta_any invalid{empty{}};
 
     ASSERT_TRUE(any);
     ASSERT_EQ(any.cast<int>(), 3);
@@ -333,7 +333,7 @@ TEST_F(MetaAny, SBOAssignValue) {
 TEST_F(MetaAny, SBOConvertAssignValue) {
     entt::meta_any any{3};
     const entt::meta_any other{1.5};
-    const entt::meta_any invalid{empty_t{}};
+    const entt::meta_any invalid{empty{}};
 
     ASSERT_TRUE(any);
     ASSERT_EQ(any.cast<int>(), 3);
@@ -347,7 +347,7 @@ TEST_F(MetaAny, SBOAsRefAssignValue) {
     int value = 3;
     entt::meta_any any{entt::forward_as_meta(value)};
     const entt::meta_any other{1};
-    const entt::meta_any invalid{empty_t{}};
+    const entt::meta_any invalid{empty{}};
 
     ASSERT_TRUE(any);
     ASSERT_EQ(any.cast<int>(), 3);
@@ -362,7 +362,7 @@ TEST_F(MetaAny, SBOAsConstRefAssignValue) {
     const int value = 3;
     entt::meta_any any{entt::forward_as_meta(value)};
     const entt::meta_any other{1};
-    const entt::meta_any invalid{empty_t{}};
+    const entt::meta_any invalid{empty{}};
 
     ASSERT_TRUE(any);
     ASSERT_EQ(any.cast<int>(), 3);
@@ -380,7 +380,7 @@ TEST_F(MetaAny, SBOTransferValue) {
     ASSERT_EQ(any.cast<int>(), 3);
 
     ASSERT_TRUE(any.assign(1));
-    ASSERT_FALSE(any.assign(empty_t{}));
+    ASSERT_FALSE(any.assign(empty{}));
     ASSERT_EQ(any.cast<int>(), 1);
 }
 
@@ -402,7 +402,7 @@ TEST_F(MetaAny, SBOConvertTransferValue) {
     ASSERT_EQ(any.cast<int>(), 3);
 
     ASSERT_TRUE(any.assign(1.5));
-    ASSERT_FALSE(any.assign(empty_t{}));
+    ASSERT_FALSE(any.assign(empty{}));
     ASSERT_EQ(any.cast<int>(), 1);
 }
 
@@ -414,7 +414,7 @@ TEST_F(MetaAny, SBOAsRefTransferValue) {
     ASSERT_EQ(any.cast<int>(), 3);
 
     ASSERT_TRUE(any.assign(1));
-    ASSERT_FALSE(any.assign(empty_t{}));
+    ASSERT_FALSE(any.assign(empty{}));
     ASSERT_EQ(any.cast<int>(), 1);
     ASSERT_EQ(value, 1);
 }
@@ -427,114 +427,114 @@ TEST_F(MetaAny, SBOAsConstRefTransferValue) {
     ASSERT_EQ(any.cast<int>(), 3);
 
     ASSERT_FALSE(any.assign(1));
-    ASSERT_FALSE(any.assign(empty_t{}));
+    ASSERT_FALSE(any.assign(empty{}));
     ASSERT_EQ(any.cast<int>(), 3);
     ASSERT_EQ(value, 3);
 }
 
 TEST_F(MetaAny, NoSBOInPlaceTypeConstruction) {
-    const fat_t instance{.1, .2, .3, .4};
-    entt::meta_any any{std::in_place_type<fat_t>, instance};
+    const fat instance{.1, .2, .3, .4};
+    entt::meta_any any{std::in_place_type<fat>, instance};
 
     ASSERT_TRUE(any);
     ASSERT_FALSE(any.try_cast<std::size_t>());
-    ASSERT_EQ(any.cast<fat_t>(), instance);
+    ASSERT_EQ(any.cast<fat>(), instance);
     ASSERT_NE(any.data(), nullptr);
-    ASSERT_EQ(any, (entt::meta_any{std::in_place_type<fat_t>, instance}));
+    ASSERT_EQ(any, (entt::meta_any{std::in_place_type<fat>, instance}));
     ASSERT_EQ(any, entt::meta_any{instance});
-    ASSERT_NE(entt::meta_any{fat_t{}}, any);
+    ASSERT_NE(entt::meta_any{fat{}}, any);
 }
 
 TEST_F(MetaAny, NoSBOAsRefConstruction) {
-    fat_t instance{.1, .2, .3, .4};
+    fat instance{.1, .2, .3, .4};
     auto any = entt::forward_as_meta(instance);
 
     ASSERT_TRUE(any);
     ASSERT_EQ(any.policy(), entt::meta_any_policy::ref);
-    ASSERT_EQ(any.type(), entt::resolve<fat_t>());
+    ASSERT_EQ(any.type(), entt::resolve<fat>());
 
     ASSERT_FALSE(any.try_cast<std::size_t>());
-    ASSERT_EQ(any.cast<fat_t &>(), instance);
-    ASSERT_EQ(any.cast<const fat_t &>(), instance);
-    ASSERT_EQ(any.cast<fat_t>(), instance);
+    ASSERT_EQ(any.cast<fat &>(), instance);
+    ASSERT_EQ(any.cast<const fat &>(), instance);
+    ASSERT_EQ(any.cast<fat>(), instance);
     ASSERT_EQ(any.data(), &instance);
     ASSERT_EQ(std::as_const(any).data(), &instance);
 
     ASSERT_EQ(any, entt::forward_as_meta(instance));
 
     ASSERT_EQ(any, entt::meta_any{instance});
-    ASSERT_NE(entt::meta_any{fat_t{}}, any);
+    ASSERT_NE(entt::meta_any{fat{}}, any);
 
     any = entt::forward_as_meta(instance);
 
     ASSERT_TRUE(any);
-    ASSERT_EQ(any.type(), entt::resolve<fat_t>());
+    ASSERT_EQ(any.type(), entt::resolve<fat>());
     ASSERT_EQ(std::as_const(any).data(), &instance);
 
     auto other = any.as_ref();
 
     ASSERT_TRUE(other);
-    ASSERT_EQ(any.type(), entt::resolve<fat_t>());
+    ASSERT_EQ(any.type(), entt::resolve<fat>());
     ASSERT_EQ(any, entt::meta_any{instance});
     ASSERT_EQ(other.data(), any.data());
 }
 
 TEST_F(MetaAny, NoSBOAsConstRefConstruction) {
-    const fat_t instance{.1, .2, .3, .4};
+    const fat instance{.1, .2, .3, .4};
     auto any = entt::forward_as_meta(instance);
 
     ASSERT_TRUE(any);
     ASSERT_EQ(any.policy(), entt::meta_any_policy::cref);
-    ASSERT_EQ(any.type(), entt::resolve<fat_t>());
+    ASSERT_EQ(any.type(), entt::resolve<fat>());
 
     ASSERT_FALSE(any.try_cast<std::size_t>());
-    ASSERT_EQ(any.cast<const fat_t &>(), instance);
-    ASSERT_EQ(any.cast<fat_t>(), instance);
+    ASSERT_EQ(any.cast<const fat &>(), instance);
+    ASSERT_EQ(any.cast<fat>(), instance);
     ASSERT_EQ(any.data(), nullptr);
     ASSERT_EQ(std::as_const(any).data(), &instance);
 
     ASSERT_EQ(any, entt::forward_as_meta(instance));
 
     ASSERT_EQ(any, entt::meta_any{instance});
-    ASSERT_NE(entt::meta_any{fat_t{}}, any);
+    ASSERT_NE(entt::meta_any{fat{}}, any);
 
     any = entt::forward_as_meta(std::as_const(instance));
 
     ASSERT_TRUE(any);
-    ASSERT_EQ(any.type(), entt::resolve<fat_t>());
+    ASSERT_EQ(any.type(), entt::resolve<fat>());
     ASSERT_EQ(std::as_const(any).data(), &instance);
 
     auto other = any.as_ref();
 
     ASSERT_TRUE(other);
-    ASSERT_EQ(any.type(), entt::resolve<fat_t>());
+    ASSERT_EQ(any.type(), entt::resolve<fat>());
     ASSERT_EQ(any, entt::meta_any{instance});
     ASSERT_EQ(other.data(), any.data());
 }
 
 ENTT_DEBUG_TEST_F(MetaAnyDeathTest, NoSBOAsConstRefConstruction) {
-    const fat_t instance{.1, .2, .3, .4};
+    const fat instance{.1, .2, .3, .4};
     auto any = entt::forward_as_meta(instance);
 
     ASSERT_TRUE(any);
-    ASSERT_DEATH(any.cast<fat_t &>() = {}, "");
+    ASSERT_DEATH(any.cast<fat &>() = {}, "");
 }
 
 TEST_F(MetaAny, NoSBOCopyConstruction) {
-    const fat_t instance{.1, .2, .3, .4};
+    const fat instance{.1, .2, .3, .4};
     const entt::meta_any any{instance};
     entt::meta_any other{any};
 
     ASSERT_TRUE(any);
     ASSERT_TRUE(other);
     ASSERT_FALSE(other.try_cast<std::size_t>());
-    ASSERT_EQ(other.cast<fat_t>(), instance);
+    ASSERT_EQ(other.cast<fat>(), instance);
     ASSERT_EQ(other, entt::meta_any{instance});
-    ASSERT_NE(other, fat_t{});
+    ASSERT_NE(other, fat{});
 }
 
 TEST_F(MetaAny, NoSBOCopyAssignment) {
-    const fat_t instance{.1, .2, .3, .4};
+    const fat instance{.1, .2, .3, .4};
     const entt::meta_any any{instance};
     entt::meta_any other{3};
 
@@ -543,13 +543,13 @@ TEST_F(MetaAny, NoSBOCopyAssignment) {
     ASSERT_TRUE(any);
     ASSERT_TRUE(other);
     ASSERT_FALSE(other.try_cast<std::size_t>());
-    ASSERT_EQ(other.cast<fat_t>(), instance);
+    ASSERT_EQ(other.cast<fat>(), instance);
     ASSERT_EQ(other, entt::meta_any{instance});
-    ASSERT_NE(other, fat_t{});
+    ASSERT_NE(other, fat{});
 }
 
 TEST_F(MetaAny, NoSBOMoveConstruction) {
-    const fat_t instance{.1, .2, .3, .4};
+    const fat instance{.1, .2, .3, .4};
     entt::meta_any any{instance};
     entt::meta_any other{std::move(any)};
 
@@ -558,13 +558,13 @@ TEST_F(MetaAny, NoSBOMoveConstruction) {
     ASSERT_FALSE(any);
     ASSERT_TRUE(other);
     ASSERT_FALSE(other.try_cast<std::size_t>());
-    ASSERT_EQ(other.cast<fat_t>(), instance);
+    ASSERT_EQ(other.cast<fat>(), instance);
     ASSERT_EQ(other, entt::meta_any{instance});
-    ASSERT_NE(other, fat_t{});
+    ASSERT_NE(other, fat{});
 }
 
 TEST_F(MetaAny, NoSBOMoveAssignment) {
-    const fat_t instance{.1, .2, .3, .4};
+    const fat instance{.1, .2, .3, .4};
     entt::meta_any any{instance};
     entt::meta_any other{3};
 
@@ -574,41 +574,41 @@ TEST_F(MetaAny, NoSBOMoveAssignment) {
     ASSERT_FALSE(any);
     ASSERT_TRUE(other);
     ASSERT_FALSE(other.try_cast<std::size_t>());
-    ASSERT_EQ(other.cast<fat_t>(), instance);
+    ASSERT_EQ(other.cast<fat>(), instance);
     ASSERT_EQ(other, entt::meta_any{instance});
-    ASSERT_NE(other, fat_t{});
+    ASSERT_NE(other, fat{});
 }
 
 TEST_F(MetaAny, NoSBODirectAssignment) {
-    const fat_t instance{.1, .2, .3, .4};
+    const fat instance{.1, .2, .3, .4};
     entt::meta_any any{};
     any = instance;
 
     ASSERT_FALSE(any.try_cast<std::size_t>());
-    ASSERT_EQ(any.cast<fat_t>(), instance);
-    ASSERT_EQ(any, (entt::meta_any{fat_t{.1, .2, .3, .4}}));
-    ASSERT_NE(any, fat_t{});
+    ASSERT_EQ(any.cast<fat>(), instance);
+    ASSERT_EQ(any, (entt::meta_any{fat{.1, .2, .3, .4}}));
+    ASSERT_NE(any, fat{});
 }
 
 TEST_F(MetaAny, NoSBOAssignValue) {
-    entt::meta_any any{fat_t{.1, .2, .3, .4}};
-    const entt::meta_any other{fat_t{.0, .1, .2, .3}};
+    entt::meta_any any{fat{.1, .2, .3, .4}};
+    const entt::meta_any other{fat{.0, .1, .2, .3}};
     const entt::meta_any invalid{'c'};
 
     const void *addr = std::as_const(any).data();
 
     ASSERT_TRUE(any);
-    ASSERT_EQ(any.cast<const fat_t &>(), (fat_t{.1, .2, .3, .4}));
+    ASSERT_EQ(any.cast<const fat &>(), (fat{.1, .2, .3, .4}));
 
     ASSERT_TRUE(any.assign(other));
     ASSERT_FALSE(any.assign(invalid));
-    ASSERT_EQ(any.cast<const fat_t &>(), (fat_t{.0, .1, .2, .3}));
+    ASSERT_EQ(any.cast<const fat &>(), (fat{.0, .1, .2, .3}));
     ASSERT_EQ(addr, std::as_const(any).data());
 }
 
 TEST_F(MetaAny, NoSBOConvertAssignValue) {
-    entt::meta_any any{empty_t{}};
-    const entt::meta_any other{fat_t{.0, .1, .2, .3}};
+    entt::meta_any any{empty{}};
+    const entt::meta_any other{fat{.0, .1, .2, .3}};
     const entt::meta_any invalid{'c'};
 
     const void *addr = std::as_const(any).data();
@@ -620,103 +620,103 @@ TEST_F(MetaAny, NoSBOConvertAssignValue) {
 }
 
 TEST_F(MetaAny, NoSBOAsRefAssignValue) {
-    fat_t instance{.1, .2, .3, .4};
+    fat instance{.1, .2, .3, .4};
     entt::meta_any any{entt::forward_as_meta(instance)};
-    const entt::meta_any other{fat_t{.0, .1, .2, .3}};
+    const entt::meta_any other{fat{.0, .1, .2, .3}};
     const entt::meta_any invalid{'c'};
 
     ASSERT_TRUE(any);
-    ASSERT_EQ(any.cast<const fat_t &>(), (fat_t{.1, .2, .3, .4}));
+    ASSERT_EQ(any.cast<const fat &>(), (fat{.1, .2, .3, .4}));
 
     ASSERT_TRUE(any.assign(other));
     ASSERT_FALSE(any.assign(invalid));
-    ASSERT_EQ(any.cast<const fat_t &>(), (fat_t{.0, .1, .2, .3}));
-    ASSERT_EQ(instance, (fat_t{.0, .1, .2, .3}));
+    ASSERT_EQ(any.cast<const fat &>(), (fat{.0, .1, .2, .3}));
+    ASSERT_EQ(instance, (fat{.0, .1, .2, .3}));
 }
 
 TEST_F(MetaAny, NoSBOAsConstRefAssignValue) {
-    const fat_t instance{.1, .2, .3, .4};
+    const fat instance{.1, .2, .3, .4};
     entt::meta_any any{entt::forward_as_meta(instance)};
-    const entt::meta_any other{fat_t{.0, .1, .2, .3}};
+    const entt::meta_any other{fat{.0, .1, .2, .3}};
     const entt::meta_any invalid{'c'};
 
     ASSERT_TRUE(any);
-    ASSERT_EQ(any.cast<const fat_t &>(), (fat_t{.1, .2, .3, .4}));
+    ASSERT_EQ(any.cast<const fat &>(), (fat{.1, .2, .3, .4}));
 
     ASSERT_FALSE(any.assign(other));
     ASSERT_FALSE(any.assign(invalid));
-    ASSERT_EQ(any.cast<const fat_t &>(), (fat_t{.1, .2, .3, .4}));
-    ASSERT_EQ(instance, (fat_t{.1, .2, .3, .4}));
+    ASSERT_EQ(any.cast<const fat &>(), (fat{.1, .2, .3, .4}));
+    ASSERT_EQ(instance, (fat{.1, .2, .3, .4}));
 }
 
 TEST_F(MetaAny, NoSBOTransferValue) {
-    entt::meta_any any{fat_t{.1, .2, .3, .4}};
+    entt::meta_any any{fat{.1, .2, .3, .4}};
 
     const void *addr = std::as_const(any).data();
 
     ASSERT_TRUE(any);
-    ASSERT_EQ(any.cast<const fat_t &>(), (fat_t{.1, .2, .3, .4}));
+    ASSERT_EQ(any.cast<const fat &>(), (fat{.1, .2, .3, .4}));
 
-    ASSERT_TRUE(any.assign(fat_t{.0, .1, .2, .3}));
+    ASSERT_TRUE(any.assign(fat{.0, .1, .2, .3}));
     ASSERT_FALSE(any.assign('c'));
-    ASSERT_EQ(any.cast<const fat_t &>(), (fat_t{.0, .1, .2, .3}));
+    ASSERT_EQ(any.cast<const fat &>(), (fat{.0, .1, .2, .3}));
     ASSERT_EQ(addr, std::as_const(any).data());
 }
 
 TEST_F(MetaAny, NoSBOTransferConstValue) {
-    const fat_t instance{.0, .1, .2, .3};
-    entt::meta_any any{fat_t{.1, .2, .3, .4}};
+    const fat instance{.0, .1, .2, .3};
+    entt::meta_any any{fat{.1, .2, .3, .4}};
 
     const void *addr = std::as_const(any).data();
 
     ASSERT_TRUE(any);
-    ASSERT_EQ(any.cast<const fat_t &>(), (fat_t{.1, .2, .3, .4}));
+    ASSERT_EQ(any.cast<const fat &>(), (fat{.1, .2, .3, .4}));
 
     ASSERT_TRUE(any.assign(entt::forward_as_meta(instance)));
-    ASSERT_EQ(any.cast<const fat_t &>(), (fat_t{.0, .1, .2, .3}));
+    ASSERT_EQ(any.cast<const fat &>(), (fat{.0, .1, .2, .3}));
     ASSERT_EQ(addr, std::as_const(any).data());
 }
 
 TEST_F(MetaAny, NoSBOConvertTransferValue) {
-    entt::meta_any any{empty_t{}};
+    entt::meta_any any{empty{}};
 
     const void *addr = std::as_const(any).data();
 
     ASSERT_TRUE(any);
-    ASSERT_TRUE(any.assign(fat_t{.0, .1, .2, .3}));
+    ASSERT_TRUE(any.assign(fat{.0, .1, .2, .3}));
     ASSERT_FALSE(any.assign('c'));
     ASSERT_EQ(addr, std::as_const(any).data());
 }
 
 TEST_F(MetaAny, NoSBOAsRefTransferValue) {
-    fat_t instance{.1, .2, .3, .4};
+    fat instance{.1, .2, .3, .4};
     entt::meta_any any{entt::forward_as_meta(instance)};
 
     const void *addr = std::as_const(any).data();
 
     ASSERT_TRUE(any);
-    ASSERT_EQ(any.cast<const fat_t &>(), (fat_t{.1, .2, .3, .4}));
+    ASSERT_EQ(any.cast<const fat &>(), (fat{.1, .2, .3, .4}));
 
-    ASSERT_TRUE(any.assign(fat_t{.0, .1, .2, .3}));
+    ASSERT_TRUE(any.assign(fat{.0, .1, .2, .3}));
     ASSERT_FALSE(any.assign('c'));
-    ASSERT_EQ(any.cast<const fat_t &>(), (fat_t{.0, .1, .2, .3}));
-    ASSERT_EQ(instance, (fat_t{.0, .1, .2, .3}));
+    ASSERT_EQ(any.cast<const fat &>(), (fat{.0, .1, .2, .3}));
+    ASSERT_EQ(instance, (fat{.0, .1, .2, .3}));
     ASSERT_EQ(addr, std::as_const(any).data());
 }
 
 TEST_F(MetaAny, NoSBOAsConstRefTransferValue) {
-    const fat_t instance{.1, .2, .3, .4};
+    const fat instance{.1, .2, .3, .4};
     entt::meta_any any{entt::forward_as_meta(instance)};
 
     const void *addr = std::as_const(any).data();
 
     ASSERT_TRUE(any);
-    ASSERT_EQ(any.cast<const fat_t &>(), (fat_t{.1, .2, .3, .4}));
+    ASSERT_EQ(any.cast<const fat &>(), (fat{.1, .2, .3, .4}));
 
-    ASSERT_FALSE(any.assign(fat_t{.0, .1, .2, .3}));
+    ASSERT_FALSE(any.assign(fat{.0, .1, .2, .3}));
     ASSERT_FALSE(any.assign('c'));
-    ASSERT_EQ(any.cast<const fat_t &>(), (fat_t{.1, .2, .3, .4}));
-    ASSERT_EQ(instance, (fat_t{.1, .2, .3, .4}));
+    ASSERT_EQ(any.cast<const fat &>(), (fat{.1, .2, .3, .4}));
+    ASSERT_EQ(instance, (fat{.1, .2, .3, .4}));
     ASSERT_EQ(addr, std::as_const(any).data());
 }
 
@@ -795,7 +795,7 @@ TEST_F(MetaAny, SBOMoveInvalidate) {
 }
 
 TEST_F(MetaAny, NoSBOMoveInvalidate) {
-    const fat_t instance{.1, .2, .3, .4};
+    const fat instance{.1, .2, .3, .4};
     entt::meta_any any{instance};
     entt::meta_any other{std::move(any)};
     const entt::meta_any valid = std::move(other);
@@ -823,28 +823,28 @@ TEST_F(MetaAny, VoidMoveInvalidate) {
 
 TEST_F(MetaAny, SBODestruction) {
     {
-        entt::meta_any any{std::in_place_type<empty_t>};
-        any.emplace<empty_t>();
-        any = empty_t{};
+        entt::meta_any any{std::in_place_type<empty>};
+        any.emplace<empty>();
+        any = empty{};
         entt::meta_any other{std::move(any)};
         any = std::move(other);
     }
 
-    ASSERT_EQ(empty_t::destroy_counter, 3);
-    ASSERT_EQ(empty_t::destructor_counter, 6);
+    ASSERT_EQ(empty::destroy_counter, 3);
+    ASSERT_EQ(empty::destructor_counter, 6);
 }
 
 TEST_F(MetaAny, NoSBODestruction) {
     {
-        entt::meta_any any{std::in_place_type<fat_t>, 1., 2., 3., 4.};
-        any.emplace<fat_t>(1., 2., 3., 4.);
-        any = fat_t{1., 2., 3., 4.};
+        entt::meta_any any{std::in_place_type<fat>, 1., 2., 3., 4.};
+        any.emplace<fat>(1., 2., 3., 4.);
+        any = fat{1., 2., 3., 4.};
         entt::meta_any other{std::move(any)};
         any = std::move(other);
     }
 
-    ASSERT_EQ(fat_t::destroy_counter, 3);
-    ASSERT_EQ(empty_t::destructor_counter, 4);
+    ASSERT_EQ(fat::destroy_counter, 3);
+    ASSERT_EQ(empty::destructor_counter, 4);
 }
 
 TEST_F(MetaAny, VoidDestruction) {
@@ -900,13 +900,13 @@ TEST_F(MetaAny, SBOSwap) {
 }
 
 TEST_F(MetaAny, NoSBOSwap) {
-    entt::meta_any lhs{fat_t{.1, .2, .3, .4}};
-    entt::meta_any rhs{fat_t{.4, .3, .2, .1}};
+    entt::meta_any lhs{fat{.1, .2, .3, .4}};
+    entt::meta_any rhs{fat{.4, .3, .2, .1}};
 
     std::swap(lhs, rhs);
 
-    ASSERT_EQ(lhs.cast<fat_t>(), (fat_t{.4, .3, .2, .1}));
-    ASSERT_EQ(rhs.cast<fat_t>(), (fat_t{.1, .2, .3, .4}));
+    ASSERT_EQ(lhs.cast<fat>(), (fat{.4, .3, .2, .1}));
+    ASSERT_EQ(rhs.cast<fat>(), (fat{.1, .2, .3, .4}));
 }
 
 TEST_F(MetaAny, VoidSwap) {
@@ -920,15 +920,15 @@ TEST_F(MetaAny, VoidSwap) {
 }
 
 TEST_F(MetaAny, SBOWithNoSBOSwap) {
-    entt::meta_any lhs{fat_t{.1, .2, .3, .4}};
+    entt::meta_any lhs{fat{.1, .2, .3, .4}};
     entt::meta_any rhs{'c'};
 
     std::swap(lhs, rhs);
 
-    ASSERT_FALSE(lhs.try_cast<fat_t>());
+    ASSERT_FALSE(lhs.try_cast<fat>());
     ASSERT_EQ(lhs.cast<char>(), 'c');
     ASSERT_FALSE(rhs.try_cast<char>());
-    ASSERT_EQ(rhs.cast<fat_t>(), (fat_t{.1, .2, .3, .4}));
+    ASSERT_EQ(rhs.cast<fat>(), (fat{.1, .2, .3, .4}));
 }
 
 TEST_F(MetaAny, SBOWithEmptySwap) {
@@ -957,33 +957,33 @@ TEST_F(MetaAny, SBOWithVoidSwap) {
 }
 
 TEST_F(MetaAny, NoSBOWithEmptySwap) {
-    entt::meta_any lhs{fat_t{.1, .2, .3, .4}};
+    entt::meta_any lhs{fat{.1, .2, .3, .4}};
     entt::meta_any rhs{};
 
     std::swap(lhs, rhs);
 
     ASSERT_FALSE(lhs);
-    ASSERT_EQ(rhs.cast<fat_t>(), (fat_t{.1, .2, .3, .4}));
+    ASSERT_EQ(rhs.cast<fat>(), (fat{.1, .2, .3, .4}));
 
     std::swap(lhs, rhs);
 
     ASSERT_FALSE(rhs);
-    ASSERT_EQ(lhs.cast<fat_t>(), (fat_t{.1, .2, .3, .4}));
+    ASSERT_EQ(lhs.cast<fat>(), (fat{.1, .2, .3, .4}));
 }
 
 TEST_F(MetaAny, NoSBOWithVoidSwap) {
-    entt::meta_any lhs{fat_t{.1, .2, .3, .4}};
+    entt::meta_any lhs{fat{.1, .2, .3, .4}};
     entt::meta_any rhs{std::in_place_type<void>};
 
     std::swap(lhs, rhs);
 
     ASSERT_EQ(lhs.type(), entt::resolve<void>());
-    ASSERT_EQ(rhs.cast<fat_t>(), (fat_t{.1, .2, .3, .4}));
+    ASSERT_EQ(rhs.cast<fat>(), (fat{.1, .2, .3, .4}));
 
     std::swap(lhs, rhs);
 
     ASSERT_EQ(rhs.type(), entt::resolve<void>());
-    ASSERT_EQ(lhs.cast<fat_t>(), (fat_t{.1, .2, .3, .4}));
+    ASSERT_EQ(lhs.cast<fat>(), (fat{.1, .2, .3, .4}));
 }
 
 TEST_F(MetaAny, AsRef) {
@@ -1107,74 +1107,74 @@ TEST_F(MetaAny, CompareVoid) {
 }
 
 TEST_F(MetaAny, TryCast) {
-    entt::meta_any any{fat_t{}};
+    entt::meta_any any{fat{}};
 
     ASSERT_TRUE(any);
-    ASSERT_EQ(any.type(), entt::resolve<fat_t>());
+    ASSERT_EQ(any.type(), entt::resolve<fat>());
     ASSERT_EQ(any.try_cast<void>(), nullptr);
-    ASSERT_NE(any.try_cast<empty_t>(), nullptr);
-    ASSERT_EQ(any.try_cast<fat_t>(), any.data());
-    ASSERT_EQ(std::as_const(any).try_cast<empty_t>(), any.try_cast<empty_t>());
-    ASSERT_EQ(std::as_const(any).try_cast<fat_t>(), any.data());
+    ASSERT_NE(any.try_cast<empty>(), nullptr);
+    ASSERT_EQ(any.try_cast<fat>(), any.data());
+    ASSERT_EQ(std::as_const(any).try_cast<empty>(), any.try_cast<empty>());
+    ASSERT_EQ(std::as_const(any).try_cast<fat>(), any.data());
     ASSERT_EQ(std::as_const(any).try_cast<int>(), nullptr);
 }
 
 TEST_F(MetaAny, Cast) {
-    entt::meta_any any{fat_t{}};
+    entt::meta_any any{fat{}};
 
     ASSERT_TRUE(any);
-    ASSERT_EQ(any.type(), entt::resolve<fat_t>());
-    ASSERT_EQ(std::as_const(any).cast<const fat_t &>(), fat_t{});
-    ASSERT_EQ(any.cast<const fat_t>(), fat_t{});
-    ASSERT_EQ(any.cast<fat_t &>(), fat_t{});
-    ASSERT_EQ(any.cast<fat_t>(), fat_t{});
+    ASSERT_EQ(any.type(), entt::resolve<fat>());
+    ASSERT_EQ(std::as_const(any).cast<const fat &>(), fat{});
+    ASSERT_EQ(any.cast<const fat>(), fat{});
+    ASSERT_EQ(any.cast<fat &>(), fat{});
+    ASSERT_EQ(any.cast<fat>(), fat{});
 
-    ASSERT_EQ(any.cast<fat_t>().value[0u], 0.);
+    ASSERT_EQ(any.cast<fat>().value[0u], 0.);
 
-    any.cast<fat_t &>().value[0u] = 3.;
+    any.cast<fat &>().value[0u] = 3.;
 
-    ASSERT_EQ(any.cast<fat_t>().value[0u], 3.);
+    ASSERT_EQ(any.cast<fat>().value[0u], 3.);
 }
 
 TEST_F(MetaAny, AllowCast) {
-    entt::meta_any clazz{clazz_t{}};
-    entt::meta_any fat{fat_t{}};
+    entt::meta_any instance{clazz{}};
+    entt::meta_any other{fat{}};
     entt::meta_any arithmetic{3};
     auto as_cref = entt::forward_as_meta(arithmetic.cast<const int &>());
 
-    ASSERT_TRUE(clazz);
-    ASSERT_TRUE(fat);
+    ASSERT_TRUE(instance);
+    ASSERT_TRUE(other);
     ASSERT_TRUE(arithmetic);
     ASSERT_TRUE(as_cref);
 
-    ASSERT_TRUE(clazz.allow_cast<clazz_t>());
-    ASSERT_TRUE(clazz.allow_cast<clazz_t &>());
-    ASSERT_TRUE(clazz.allow_cast<const clazz_t &>());
-    ASSERT_EQ(clazz.type(), entt::resolve<clazz_t>());
-
-    ASSERT_TRUE(clazz.allow_cast<const int &>());
-    ASSERT_EQ(clazz.type(), entt::resolve<int>());
-    ASSERT_TRUE(clazz.allow_cast<int>());
-    ASSERT_TRUE(clazz.allow_cast<int &>());
-    ASSERT_TRUE(clazz.allow_cast<const int &>());
-
-    ASSERT_TRUE(fat.allow_cast<fat_t>());
-    ASSERT_TRUE(fat.allow_cast<fat_t &>());
-    ASSERT_TRUE(fat.allow_cast<const empty_t &>());
-    ASSERT_EQ(fat.type(), entt::resolve<fat_t>());
-    ASSERT_FALSE(fat.allow_cast<int>());
-
-    ASSERT_TRUE(std::as_const(fat).allow_cast<fat_t>());
-    ASSERT_FALSE(std::as_const(fat).allow_cast<fat_t &>());
-    ASSERT_TRUE(std::as_const(fat).allow_cast<const empty_t &>());
-    ASSERT_EQ(fat.type(), entt::resolve<fat_t>());
-    ASSERT_FALSE(fat.allow_cast<int>());
+    ASSERT_TRUE(instance.allow_cast<clazz>());
+    ASSERT_TRUE(instance.allow_cast<clazz &>());
+    ASSERT_TRUE(instance.allow_cast<const clazz &>());
+    ASSERT_EQ(instance.type(), entt::resolve<clazz>());
+
+    ASSERT_TRUE(instance.allow_cast<const int &>());
+    ASSERT_EQ(instance.type(), entt::resolve<int>());
+    ASSERT_TRUE(instance.allow_cast<int>());
+    ASSERT_TRUE(instance.allow_cast<int &>());
+    ASSERT_TRUE(instance.allow_cast<const int &>());
+
+    ASSERT_TRUE(other.allow_cast<fat>());
+    ASSERT_TRUE(other.allow_cast<fat &>());
+    ASSERT_TRUE(other.allow_cast<const empty &>());
+    ASSERT_EQ(other.type(), entt::resolve<fat>());
+    ASSERT_FALSE(other.allow_cast<int>());
+
+    ASSERT_TRUE(std::as_const(other).allow_cast<fat>());
+    ASSERT_FALSE(std::as_const(other).allow_cast<fat &>());
+    ASSERT_TRUE(std::as_const(other).allow_cast<const empty &>());
+    ASSERT_EQ(other.type(), entt::resolve<fat>());
+    ASSERT_FALSE(other.allow_cast<int>());
 
     ASSERT_TRUE(arithmetic.allow_cast<int>());
     ASSERT_TRUE(arithmetic.allow_cast<int &>());
     ASSERT_TRUE(arithmetic.allow_cast<const int &>());
     ASSERT_EQ(arithmetic.type(), entt::resolve<int>());
-    ASSERT_FALSE(arithmetic.allow_cast<fat_t>());
+    ASSERT_FALSE(arithmetic.allow_cast<fat>());
 
     ASSERT_TRUE(arithmetic.allow_cast<double &>());
     ASSERT_EQ(arithmetic.type(), entt::resolve<double>());
@@ -1188,43 +1188,43 @@ TEST_F(MetaAny, AllowCast) {
     ASSERT_FALSE(as_cref.allow_cast<int &>());
     ASSERT_TRUE(as_cref.allow_cast<const int &>());
     ASSERT_EQ(as_cref.type(), entt::resolve<int>());
-    ASSERT_FALSE(as_cref.allow_cast<fat_t>());
+    ASSERT_FALSE(as_cref.allow_cast<fat>());
 
     ASSERT_TRUE(as_cref.allow_cast<double &>());
     ASSERT_EQ(as_cref.type(), entt::resolve<double>());
 }
 
 TEST_F(MetaAny, OpaqueAllowCast) {
-    entt::meta_any clazz{clazz_t{}};
-    entt::meta_any fat{fat_t{}};
+    entt::meta_any instance{clazz{}};
+    entt::meta_any other{fat{}};
     entt::meta_any arithmetic{3};
     auto as_cref = entt::forward_as_meta(arithmetic.cast<const int &>());
 
-    ASSERT_TRUE(clazz);
-    ASSERT_TRUE(fat);
+    ASSERT_TRUE(instance);
+    ASSERT_TRUE(other);
     ASSERT_TRUE(arithmetic);
     ASSERT_TRUE(as_cref);
 
-    ASSERT_TRUE(clazz.allow_cast(entt::resolve<clazz_t>()));
-    ASSERT_EQ(clazz.type(), entt::resolve<clazz_t>());
+    ASSERT_TRUE(instance.allow_cast(entt::resolve<clazz>()));
+    ASSERT_EQ(instance.type(), entt::resolve<clazz>());
 
-    ASSERT_TRUE(clazz.allow_cast(entt::resolve<int>()));
-    ASSERT_EQ(clazz.type(), entt::resolve<int>());
-    ASSERT_TRUE(clazz.allow_cast(entt::resolve<int>()));
+    ASSERT_TRUE(instance.allow_cast(entt::resolve<int>()));
+    ASSERT_EQ(instance.type(), entt::resolve<int>());
+    ASSERT_TRUE(instance.allow_cast(entt::resolve<int>()));
 
-    ASSERT_TRUE(fat.allow_cast(entt::resolve<fat_t>()));
-    ASSERT_TRUE(fat.allow_cast(entt::resolve<empty_t>()));
-    ASSERT_EQ(fat.type(), entt::resolve<fat_t>());
-    ASSERT_FALSE(fat.allow_cast(entt::resolve<int>()));
+    ASSERT_TRUE(other.allow_cast(entt::resolve<fat>()));
+    ASSERT_TRUE(other.allow_cast(entt::resolve<empty>()));
+    ASSERT_EQ(other.type(), entt::resolve<fat>());
+    ASSERT_FALSE(other.allow_cast(entt::resolve<int>()));
 
-    ASSERT_TRUE(std::as_const(fat).allow_cast(entt::resolve<fat_t>()));
-    ASSERT_TRUE(std::as_const(fat).allow_cast(entt::resolve<empty_t>()));
-    ASSERT_EQ(fat.type(), entt::resolve<fat_t>());
-    ASSERT_FALSE(fat.allow_cast(entt::resolve<int>()));
+    ASSERT_TRUE(std::as_const(other).allow_cast(entt::resolve<fat>()));
+    ASSERT_TRUE(std::as_const(other).allow_cast(entt::resolve<empty>()));
+    ASSERT_EQ(other.type(), entt::resolve<fat>());
+    ASSERT_FALSE(other.allow_cast(entt::resolve<int>()));
 
     ASSERT_TRUE(arithmetic.allow_cast(entt::resolve<int>()));
     ASSERT_EQ(arithmetic.type(), entt::resolve<int>());
-    ASSERT_FALSE(arithmetic.allow_cast(entt::resolve<fat_t>()));
+    ASSERT_FALSE(arithmetic.allow_cast(entt::resolve<fat>()));
 
     ASSERT_TRUE(arithmetic.allow_cast(entt::resolve<double>()));
     ASSERT_EQ(arithmetic.type(), entt::resolve<double>());
@@ -1236,7 +1236,7 @@ TEST_F(MetaAny, OpaqueAllowCast) {
 
     ASSERT_TRUE(as_cref.allow_cast(entt::resolve<int>()));
     ASSERT_EQ(as_cref.type(), entt::resolve<int>());
-    ASSERT_FALSE(as_cref.allow_cast(entt::resolve<fat_t>()));
+    ASSERT_FALSE(as_cref.allow_cast(entt::resolve<fat>()));
 
     ASSERT_TRUE(as_cref.allow_cast(entt::resolve<double>()));
     ASSERT_EQ(as_cref.type(), entt::resolve<double>());
@@ -1246,14 +1246,14 @@ TEST_F(MetaAny, OpaqueAllowCast) {
 }
 
 TEST_F(MetaAny, Convert) {
-    entt::meta_any any{clazz_t{}};
-    any.cast<clazz_t &>().value = 3;
+    entt::meta_any any{clazz{}};
+    any.cast<clazz &>().value = 3;
     auto as_int = std::as_const(any).allow_cast<int>();
 
     ASSERT_TRUE(any);
-    ASSERT_EQ(any.type(), entt::resolve<clazz_t>());
-    ASSERT_TRUE(any.allow_cast<clazz_t>());
-    ASSERT_EQ(any.type(), entt::resolve<clazz_t>());
+    ASSERT_EQ(any.type(), entt::resolve<clazz>());
+    ASSERT_TRUE(any.allow_cast<clazz>());
+    ASSERT_EQ(any.type(), entt::resolve<clazz>());
     ASSERT_TRUE(any.allow_cast<int>());
     ASSERT_EQ(any.type(), entt::resolve<int>());
     ASSERT_EQ(any.cast<int>(), 3);
@@ -1322,7 +1322,7 @@ TEST_F(MetaAny, EnumConversion) {
 }
 
 TEST_F(MetaAny, UnmanageableType) {
-    unmanageable_t instance{};
+    unmanageable instance{};
     auto any = entt::forward_as_meta(instance);
     entt::meta_any other = any.as_ref();
 
@@ -1331,22 +1331,22 @@ TEST_F(MetaAny, UnmanageableType) {
     ASSERT_TRUE(any);
     ASSERT_TRUE(other);
 
-    ASSERT_EQ(any.type(), entt::resolve<unmanageable_t>());
+    ASSERT_EQ(any.type(), entt::resolve<unmanageable>());
     ASSERT_NE(any.data(), nullptr);
     ASSERT_EQ(any.try_cast<int>(), nullptr);
-    ASSERT_NE(any.try_cast<unmanageable_t>(), nullptr);
+    ASSERT_NE(any.try_cast<unmanageable>(), nullptr);
 
-    ASSERT_TRUE(any.allow_cast<unmanageable_t>());
+    ASSERT_TRUE(any.allow_cast<unmanageable>());
     ASSERT_FALSE(any.allow_cast<int>());
 
-    ASSERT_TRUE(std::as_const(any).allow_cast<unmanageable_t>());
+    ASSERT_TRUE(std::as_const(any).allow_cast<unmanageable>());
     ASSERT_FALSE(std::as_const(any).allow_cast<int>());
 }
 
 TEST_F(MetaAny, Invoke) {
     using namespace entt::literals;
 
-    clazz_t instance;
+    clazz instance;
     auto any = entt::forward_as_meta(instance);
 
     ASSERT_TRUE(any.invoke("func"_hs));
@@ -1355,14 +1355,14 @@ TEST_F(MetaAny, Invoke) {
     ASSERT_FALSE(std::as_const(any).as_ref().invoke("member"_hs, 3));
     ASSERT_FALSE(any.invoke("non_existent"_hs, 3));
 
-    ASSERT_EQ(clazz_t::c, 'd');
+    ASSERT_EQ(clazz::c, 'd');
     ASSERT_EQ(instance.value, 3);
 }
 
 TEST_F(MetaAny, SetGet) {
     using namespace entt::literals;
 
-    clazz_t instance;
+    clazz instance;
     auto any = entt::forward_as_meta(instance);
 
     ASSERT_TRUE(any.set("value"_hs, 3));

test/entt/meta/meta_base.cpp

@@ -8,13 +8,13 @@
 #include <entt/meta/node.hpp>
 #include <entt/meta/resolve.hpp>
 
-struct base_1_t {
-    base_1_t() = default;
+struct base_1 {
+    base_1() = default;
     int value_1{};
 };
 
-struct base_2_t {
-    base_2_t() = default;
+struct base_2 {
+    base_2() = default;
 
     operator int() const {
         return value_2;
@@ -23,13 +23,13 @@ struct base_2_t {
     int value_2{};
 };
 
-struct base_3_t: base_2_t {
-    base_3_t() = default;
+struct base_3: base_2 {
+    base_3() = default;
     int value_3{};
 };
 
-struct derived_t: base_1_t, base_3_t {
-    derived_t() = default;
+struct derived: base_1, base_3 {
+    derived() = default;
     int value{};
 };
 
@@ -37,22 +37,22 @@ struct MetaBase: ::testing::Test {
     void SetUp() override {
         using namespace entt::literals;
 
-        entt::meta<base_1_t>()
-            .data<&base_1_t::value_1>("value_1"_hs);
+        entt::meta<base_1>()
+            .data<&base_1::value_1>("value_1"_hs);
 
-        entt::meta<base_2_t>()
+        entt::meta<base_2>()
             .conv<int>()
-            .data<&base_2_t::value_2>("value_2"_hs);
+            .data<&base_2::value_2>("value_2"_hs);
 
-        entt::meta<base_3_t>()
-            .base<base_2_t>()
-            .data<&base_3_t::value_3>("value_3"_hs);
+        entt::meta<base_3>()
+            .base<base_2>()
+            .data<&base_3::value_3>("value_3"_hs);
 
-        entt::meta<derived_t>()
+        entt::meta<derived>()
             .type("derived"_hs)
-            .base<base_1_t>()
-            .base<base_3_t>()
-            .data<&derived_t::value>("value"_hs);
+            .base<base_1>()
+            .base<base_3>()
+            .data<&derived::value>("value"_hs);
     }
 
     void TearDown() override {
@@ -61,34 +61,34 @@ struct MetaBase: ::testing::Test {
 };
 
 TEST_F(MetaBase, Functionalities) {
-    auto any = entt::resolve<derived_t>().construct();
-    any.cast<derived_t &>().value_1 = 2;
+    auto any = entt::resolve<derived>().construct();
+    any.cast<derived &>().value_1 = 2;
     auto as_derived = any.as_ref();
 
-    ASSERT_TRUE(any.allow_cast<base_1_t &>());
+    ASSERT_TRUE(any.allow_cast<base_1 &>());
 
     ASSERT_FALSE(any.allow_cast<char>());
     ASSERT_FALSE(as_derived.allow_cast<char>());
 
     ASSERT_TRUE(any);
-    ASSERT_EQ(any.cast<base_1_t &>().value_1, as_derived.cast<derived_t &>().value_1);
+    ASSERT_EQ(any.cast<base_1 &>().value_1, as_derived.cast<derived &>().value_1);
 
-    any.cast<base_1_t &>().value_1 = 3;
+    any.cast<base_1 &>().value_1 = 3;
 
-    ASSERT_EQ(any.cast<const base_1_t &>().value_1, as_derived.cast<const derived_t &>().value_1);
+    ASSERT_EQ(any.cast<const base_1 &>().value_1, as_derived.cast<const derived &>().value_1);
 }
 
 TEST_F(MetaBase, SetGetWithMutatingThis) {
     using namespace entt::literals;
 
-    derived_t instance;
+    derived instance;
     auto any = entt::forward_as_meta(instance);
     auto as_cref = std::as_const(any).as_ref();
 
-    ASSERT_NE(static_cast<const void *>(static_cast<const base_1_t *>(&instance)), static_cast<const void *>(static_cast<const base_2_t *>(&instance)));
-    ASSERT_NE(static_cast<const void *>(static_cast<const base_1_t *>(&instance)), static_cast<const void *>(static_cast<const base_3_t *>(&instance)));
-    ASSERT_EQ(static_cast<const void *>(static_cast<const base_2_t *>(&instance)), static_cast<const void *>(static_cast<const base_3_t *>(&instance)));
-    ASSERT_EQ(static_cast<const void *>(&instance), static_cast<const void *>(static_cast<const base_1_t *>(&instance)));
+    ASSERT_NE(static_cast<const void *>(static_cast<const base_1 *>(&instance)), static_cast<const void *>(static_cast<const base_2 *>(&instance)));
+    ASSERT_NE(static_cast<const void *>(static_cast<const base_1 *>(&instance)), static_cast<const void *>(static_cast<const base_3 *>(&instance)));
+    ASSERT_EQ(static_cast<const void *>(static_cast<const base_2 *>(&instance)), static_cast<const void *>(static_cast<const base_3 *>(&instance)));
+    ASSERT_EQ(static_cast<const void *>(&instance), static_cast<const void *>(static_cast<const base_1 *>(&instance)));
 
     ASSERT_TRUE(any.set("value"_hs, 0));
     ASSERT_TRUE(any.set("value_1"_hs, 1));
@@ -117,8 +117,8 @@ TEST_F(MetaBase, SetGetWithMutatingThis) {
 }
 
 TEST_F(MetaBase, ConvWithMutatingThis) {
-    entt::meta_any any{derived_t{}};
-    auto &&ref = any.cast<derived_t &>();
+    entt::meta_any any{derived{}};
+    auto &&ref = any.cast<derived &>();
     auto as_cref = std::as_const(any).as_ref();
     ref.value_2 = 2;
 
@@ -138,9 +138,9 @@ TEST_F(MetaBase, ConvWithMutatingThis) {
 }
 
 TEST_F(MetaBase, OpaqueConvWithMutatingThis) {
-    entt::meta_any any{derived_t{}};
+    entt::meta_any any{derived{}};
     auto as_cref = std::as_const(any).as_ref();
-    any.cast<derived_t &>().value_2 = 2;
+    any.cast<derived &>().value_2 = 2;
 
     auto conv = std::as_const(any).allow_cast(entt::resolve<int>());
     auto from_cref = std::as_const(as_cref).allow_cast(entt::resolve<int>());
@@ -160,11 +160,11 @@ TEST_F(MetaBase, OpaqueConvWithMutatingThis) {
 TEST_F(MetaBase, AssignWithMutatingThis) {
     using namespace entt::literals;
 
-    entt::meta_any dst{base_2_t{}};
-    entt::meta_any src{derived_t{}};
+    entt::meta_any dst{base_2{}};
+    entt::meta_any src{derived{}};
 
-    dst.cast<base_2_t &>().value_2 = 0;
-    src.cast<derived_t &>().value_2 = 1;
+    dst.cast<base_2 &>().value_2 = 0;
+    src.cast<derived &>().value_2 = 1;
 
     ASSERT_TRUE(dst.assign(src));
     ASSERT_EQ(dst.get("value_2"_hs).cast<int>(), 1);
@@ -173,11 +173,11 @@ TEST_F(MetaBase, AssignWithMutatingThis) {
 TEST_F(MetaBase, TransferWithMutatingThis) {
     using namespace entt::literals;
 
-    entt::meta_any dst{base_2_t{}};
-    entt::meta_any src{derived_t{}};
+    entt::meta_any dst{base_2{}};
+    entt::meta_any src{derived{}};
 
-    dst.cast<base_2_t &>().value_2 = 0;
-    src.cast<derived_t &>().value_2 = 1;
+    dst.cast<base_2 &>().value_2 = 0;
+    src.cast<derived &>().value_2 = 1;
 
     ASSERT_TRUE(dst.assign(std::move(src)));
     ASSERT_EQ(dst.get("value_2"_hs).cast<int>(), 1);
@@ -186,7 +186,7 @@ TEST_F(MetaBase, TransferWithMutatingThis) {
 TEST_F(MetaBase, ReRegistration) {
     SetUp();
 
-    auto &&node = entt::internal::resolve<derived_t>(entt::internal::meta_context::from(entt::locator<entt::meta_ctx>::value_or()));
+    auto &&node = entt::internal::resolve<derived>(entt::internal::meta_context::from(entt::locator<entt::meta_ctx>::value_or()));
 
     ASSERT_TRUE(node.details);
     ASSERT_FALSE(node.details->base.empty());

test/entt/meta/meta_conv.cpp

@@ -8,8 +8,8 @@
 #include <entt/meta/node.hpp>
 #include <entt/meta/resolve.hpp>
 
-struct clazz_t {
-    clazz_t() = default;
+struct clazz {
+    clazz() = default;
 
     operator int() const {
         return value;
@@ -22,7 +22,7 @@ struct clazz_t {
     int value{};
 };
 
-double conv_to_double(const clazz_t &instance) {
+double conv_to_double(const clazz &instance) {
     return instance.value * 2.;
 }
 
@@ -30,10 +30,10 @@ struct MetaConv: ::testing::Test {
     void SetUp() override {
         using namespace entt::literals;
 
-        entt::meta<clazz_t>()
+        entt::meta<clazz>()
             .type("clazz"_hs)
             .conv<int>()
-            .conv<&clazz_t::to_bool>()
+            .conv<&clazz::to_bool>()
             .conv<conv_to_double>();
     }
 
@@ -43,8 +43,8 @@ struct MetaConv: ::testing::Test {
 };
 
 TEST_F(MetaConv, Functionalities) {
-    auto any = entt::resolve<clazz_t>().construct();
-    any.cast<clazz_t &>().value = 2;
+    auto any = entt::resolve<clazz>().construct();
+    any.cast<clazz &>().value = 2;
 
     const auto as_int = std::as_const(any).allow_cast<int>();
     const auto as_bool = std::as_const(any).allow_cast<bool>();
@@ -56,15 +56,15 @@ TEST_F(MetaConv, Functionalities) {
     ASSERT_TRUE(as_bool);
     ASSERT_TRUE(as_double);
 
-    ASSERT_EQ(as_int.cast<int>(), any.cast<clazz_t &>().operator int());
-    ASSERT_EQ(as_bool.cast<bool>(), any.cast<clazz_t &>().to_bool());
-    ASSERT_EQ(as_double.cast<double>(), conv_to_double(any.cast<clazz_t &>()));
+    ASSERT_EQ(as_int.cast<int>(), any.cast<clazz &>().operator int());
+    ASSERT_EQ(as_bool.cast<bool>(), any.cast<clazz &>().to_bool());
+    ASSERT_EQ(as_double.cast<double>(), conv_to_double(any.cast<clazz &>()));
 }
 
 TEST_F(MetaConv, ReRegistration) {
     SetUp();
 
-    auto &&node = entt::internal::resolve<clazz_t>(entt::internal::meta_context::from(entt::locator<entt::meta_ctx>::value_or()));
+    auto &&node = entt::internal::resolve<clazz>(entt::internal::meta_context::from(entt::locator<entt::meta_ctx>::value_or()));
 
     ASSERT_TRUE(node.details);
     ASSERT_FALSE(node.details->conv.empty());

test/entt/meta/meta_ctor.cpp

@@ -10,31 +10,31 @@
 #include <entt/meta/policy.hpp>
 #include <entt/meta/resolve.hpp>
 
-struct base_t {
+struct base {
     char value{'c'};
 };
 
-struct derived_t: base_t {
-    derived_t()
-        : base_t{} {}
+struct derived: base {
+    derived()
+        : base{} {}
 };
 
-struct clazz_t {
-    clazz_t(const base_t &other, int &iv)
-        : clazz_t{iv, other.value} {}
+struct clazz {
+    clazz(const base &other, int &iv)
+        : clazz{iv, other.value} {}
 
-    clazz_t(const int &iv, char cv)
+    clazz(const int &iv, char cv)
         : i{iv}, c{cv} {}
 
     operator int() const {
         return i;
     }
 
-    static clazz_t factory(int value) {
+    static clazz factory(int value) {
         return {value, 'c'};
     }
 
-    static clazz_t factory(base_t other, int value, int mul) {
+    static clazz factory(base other, int value, int mul) {
         return {value * mul, other.value};
     }
 
@@ -54,17 +54,17 @@ struct MetaCtor: ::testing::Test {
             .type("double"_hs)
             .ctor<double_factory>();
 
-        entt::meta<derived_t>()
+        entt::meta<derived>()
             .type("derived"_hs)
-            .base<base_t>();
+            .base<base>();
 
-        entt::meta<clazz_t>()
+        entt::meta<clazz>()
             .type("clazz"_hs)
-            .ctor<&entt::registry::emplace_or_replace<clazz_t, const int &, const char &>, entt::as_ref_t>()
-            .ctor<const base_t &, int &>()
+            .ctor<&entt::registry::emplace_or_replace<clazz, const int &, const char &>, entt::as_ref_t>()
+            .ctor<const base &, int &>()
             .ctor<const int &, char>()
-            .ctor<entt::overload<clazz_t(int)>(clazz_t::factory)>()
-            .ctor<entt::overload<clazz_t(base_t, int, int)>(clazz_t::factory)>()
+            .ctor<entt::overload<clazz(int)>(clazz::factory)>()
+            .ctor<entt::overload<clazz(base, int, int)>(clazz::factory)>()
             .conv<int>();
     }
 
@@ -74,117 +74,117 @@ struct MetaCtor: ::testing::Test {
 };
 
 TEST_F(MetaCtor, Functionalities) {
-    auto any = entt::resolve<clazz_t>().construct(1, 'c');
+    auto any = entt::resolve<clazz>().construct(1, 'c');
 
     ASSERT_TRUE(any);
-    ASSERT_EQ(any.cast<clazz_t>().i, 1);
-    ASSERT_EQ(any.cast<clazz_t>().c, 'c');
+    ASSERT_EQ(any.cast<clazz>().i, 1);
+    ASSERT_EQ(any.cast<clazz>().c, 'c');
 }
 
 TEST_F(MetaCtor, Func) {
-    auto any = entt::resolve<clazz_t>().construct(1);
+    auto any = entt::resolve<clazz>().construct(1);
 
     ASSERT_TRUE(any);
-    ASSERT_EQ(any.cast<clazz_t>().i, 1);
-    ASSERT_EQ(any.cast<clazz_t>().c, 'c');
+    ASSERT_EQ(any.cast<clazz>().i, 1);
+    ASSERT_EQ(any.cast<clazz>().c, 'c');
 }
 
 TEST_F(MetaCtor, MetaAnyArgs) {
-    auto any = entt::resolve<clazz_t>().construct(entt::meta_any{1}, entt::meta_any{'c'});
+    auto any = entt::resolve<clazz>().construct(entt::meta_any{1}, entt::meta_any{'c'});
 
     ASSERT_TRUE(any);
-    ASSERT_EQ(any.cast<clazz_t>().i, 1);
-    ASSERT_EQ(any.cast<clazz_t>().c, 'c');
+    ASSERT_EQ(any.cast<clazz>().i, 1);
+    ASSERT_EQ(any.cast<clazz>().c, 'c');
 }
 
 TEST_F(MetaCtor, InvalidArgs) {
-    ASSERT_FALSE(entt::resolve<clazz_t>().construct(entt::meta_any{}, derived_t{}));
+    ASSERT_FALSE(entt::resolve<clazz>().construct(entt::meta_any{}, derived{}));
 }
 
 TEST_F(MetaCtor, CastAndConvert) {
-    auto any = entt::resolve<clazz_t>().construct(derived_t{}, clazz_t{1, 'd'});
+    auto any = entt::resolve<clazz>().construct(derived{}, clazz{1, 'd'});
 
     ASSERT_TRUE(any);
-    ASSERT_EQ(any.cast<clazz_t>().i, 1);
-    ASSERT_EQ(any.cast<clazz_t>().c, 'c');
+    ASSERT_EQ(any.cast<clazz>().i, 1);
+    ASSERT_EQ(any.cast<clazz>().c, 'c');
 }
 
 TEST_F(MetaCtor, ArithmeticConversion) {
-    auto any = entt::resolve<clazz_t>().construct(true, 4.2);
+    auto any = entt::resolve<clazz>().construct(true, 4.2);
 
     ASSERT_TRUE(any);
-    ASSERT_EQ(any.cast<clazz_t>().i, 1);
-    ASSERT_EQ(any.cast<clazz_t>().c, char{4});
+    ASSERT_EQ(any.cast<clazz>().i, 1);
+    ASSERT_EQ(any.cast<clazz>().c, char{4});
 }
 
 TEST_F(MetaCtor, ConstNonConstRefArgs) {
     int ivalue = 1;
     const char cvalue = 'c';
-    auto any = entt::resolve<clazz_t>().construct(entt::forward_as_meta(ivalue), entt::forward_as_meta(cvalue));
+    auto any = entt::resolve<clazz>().construct(entt::forward_as_meta(ivalue), entt::forward_as_meta(cvalue));
 
     ASSERT_TRUE(any);
-    ASSERT_EQ(any.cast<clazz_t>().i, 1);
-    ASSERT_EQ(any.cast<clazz_t>().c, 'c');
+    ASSERT_EQ(any.cast<clazz>().i, 1);
+    ASSERT_EQ(any.cast<clazz>().c, 'c');
 }
 
 TEST_F(MetaCtor, WrongConstness) {
     int value = 1;
-    auto any = entt::resolve<clazz_t>().construct(derived_t{}, entt::forward_as_meta(value));
-    auto other = entt::resolve<clazz_t>().construct(derived_t{}, entt::forward_as_meta(std::as_const(value)));
+    auto any = entt::resolve<clazz>().construct(derived{}, entt::forward_as_meta(value));
+    auto other = entt::resolve<clazz>().construct(derived{}, entt::forward_as_meta(std::as_const(value)));
 
     ASSERT_TRUE(any);
     ASSERT_FALSE(other);
-    ASSERT_EQ(any.cast<clazz_t>().i, 1);
-    ASSERT_EQ(any.cast<clazz_t>().c, 'c');
+    ASSERT_EQ(any.cast<clazz>().i, 1);
+    ASSERT_EQ(any.cast<clazz>().c, 'c');
 }
 
 TEST_F(MetaCtor, FuncMetaAnyArgs) {
-    auto any = entt::resolve<clazz_t>().construct(entt::meta_any{1});
+    auto any = entt::resolve<clazz>().construct(entt::meta_any{1});
 
     ASSERT_TRUE(any);
-    ASSERT_EQ(any.cast<clazz_t>().i, 1);
-    ASSERT_EQ(any.cast<clazz_t>().c, 'c');
+    ASSERT_EQ(any.cast<clazz>().i, 1);
+    ASSERT_EQ(any.cast<clazz>().c, 'c');
 }
 
 TEST_F(MetaCtor, FuncCastAndConvert) {
-    auto any = entt::resolve<clazz_t>().construct(derived_t{}, 3., clazz_t{3, 'd'});
+    auto any = entt::resolve<clazz>().construct(derived{}, 3., clazz{3, 'd'});
 
     ASSERT_TRUE(any);
-    ASSERT_EQ(any.cast<clazz_t>().i, 9);
-    ASSERT_EQ(any.cast<clazz_t>().c, 'c');
+    ASSERT_EQ(any.cast<clazz>().i, 9);
+    ASSERT_EQ(any.cast<clazz>().c, 'c');
 }
 
 TEST_F(MetaCtor, FuncArithmeticConversion) {
-    auto any = entt::resolve<clazz_t>().construct(4.2);
+    auto any = entt::resolve<clazz>().construct(4.2);
 
     ASSERT_TRUE(any);
-    ASSERT_EQ(any.cast<clazz_t>().i, 4);
-    ASSERT_EQ(any.cast<clazz_t>().c, 'c');
+    ASSERT_EQ(any.cast<clazz>().i, 4);
+    ASSERT_EQ(any.cast<clazz>().c, 'c');
 }
 
 TEST_F(MetaCtor, FuncConstNonConstRefArgs) {
     int ivalue = 1;
-    auto any = entt::resolve<clazz_t>().construct(entt::forward_as_meta(ivalue));
-    auto other = entt::resolve<clazz_t>().construct(entt::forward_as_meta(std::as_const(ivalue)));
+    auto any = entt::resolve<clazz>().construct(entt::forward_as_meta(ivalue));
+    auto other = entt::resolve<clazz>().construct(entt::forward_as_meta(std::as_const(ivalue)));
 
     ASSERT_TRUE(any);
     ASSERT_TRUE(other);
-    ASSERT_EQ(any.cast<clazz_t>().i, 1);
-    ASSERT_EQ(other.cast<clazz_t>().i, 1);
+    ASSERT_EQ(any.cast<clazz>().i, 1);
+    ASSERT_EQ(other.cast<clazz>().i, 1);
 }
 
 TEST_F(MetaCtor, ExternalMemberFunction) {
     entt::registry registry;
     const auto entity = registry.create();
 
-    ASSERT_FALSE(registry.all_of<clazz_t>(entity));
+    ASSERT_FALSE(registry.all_of<clazz>(entity));
 
-    const auto any = entt::resolve<clazz_t>().construct(entt::forward_as_meta(registry), entity, 3, 'c');
+    const auto any = entt::resolve<clazz>().construct(entt::forward_as_meta(registry), entity, 3, 'c');
 
     ASSERT_TRUE(any);
-    ASSERT_TRUE(registry.all_of<clazz_t>(entity));
-    ASSERT_EQ(registry.get<clazz_t>(entity).i, 3);
-    ASSERT_EQ(registry.get<clazz_t>(entity).c, 'c');
+    ASSERT_TRUE(registry.all_of<clazz>(entity));
+    ASSERT_EQ(registry.get<clazz>(entity).i, 3);
+    ASSERT_EQ(registry.get<clazz>(entity).c, 'c');
 }
 
 TEST_F(MetaCtor, OverrideImplicitlyGeneratedDefaultConstructor) {
@@ -197,7 +197,7 @@ TEST_F(MetaCtor, OverrideImplicitlyGeneratedDefaultConstructor) {
 }
 
 TEST_F(MetaCtor, NonDefaultConstructibleType) {
-    auto type = entt::resolve<clazz_t>();
+    auto type = entt::resolve<clazz>();
     // no implicitly generated default constructor
     ASSERT_FALSE(type.construct());
 }

test/entt/meta/meta_data.cpp

@@ -14,10 +14,10 @@
 #include <entt/meta/range.hpp>
 #include <entt/meta/resolve.hpp>
 
-struct base_t {
-    virtual ~base_t() = default;
+struct base {
+    virtual ~base() = default;
 
-    static void destroy(base_t &) {
+    static void destroy(base &) {
         ++counter;
     }
 
@@ -25,23 +25,23 @@ struct base_t {
     int value{3};
 };
 
-struct derived_t: base_t {
-    derived_t() = default;
+struct derived: base {
+    derived() = default;
 };
 
-struct clazz_t {
+struct clazz {
     operator int() const {
         return h;
     }
 
     int i{0};
     const int j{1}; // NOLINT
-    base_t base{};
+    base base{};
     inline static int h{2};       // NOLINT
     inline static const int k{3}; // NOLINT
 };
 
-struct setter_getter_t {
+struct setter_getter {
     int setter(double val) {
         return value = static_cast<int>(val);
     }
@@ -58,18 +58,18 @@ struct setter_getter_t {
         return value;
     }
 
-    static int static_setter(setter_getter_t &type, int value) {
+    static int static_setter(setter_getter &type, int value) {
         return type.value = value;
     }
 
-    static int static_getter(const setter_getter_t &type) {
+    static int static_getter(const setter_getter &type) {
         return type.value;
     }
 
     int value{0};
 };
 
-struct multi_setter_t {
+struct multi_setter {
     void from_double(double val) {
         value = static_cast<int>(val);
     }
@@ -81,12 +81,12 @@ struct multi_setter_t {
     int value{0};
 };
 
-struct array_t {
+struct array {
     inline static int global[2]; // NOLINT
     int local[4];                // NOLINT
 };
 
-enum class property_t : entt::id_type {
+enum class property_type : entt::id_type {
     random,
     value
 };
@@ -95,51 +95,51 @@ struct MetaData: ::testing::Test {
     void SetUp() override {
         using namespace entt::literals;
 
-        entt::meta<base_t>()
+        entt::meta<base>()
             .type("base"_hs)
-            .dtor<base_t::destroy>()
-            .data<&base_t::value>("value"_hs);
+            .dtor<base::destroy>()
+            .data<&base::value>("value"_hs);
 
-        entt::meta<derived_t>()
+        entt::meta<derived>()
             .type("derived"_hs)
-            .base<base_t>()
-            .dtor<derived_t::destroy>()
-            .data<&base_t::value>("value_from_base"_hs);
+            .base<base>()
+            .dtor<derived::destroy>()
+            .data<&base::value>("value_from_base"_hs);
 
-        entt::meta<clazz_t>()
+        entt::meta<clazz>()
             .type("clazz"_hs)
-            .data<&clazz_t::i, entt::as_ref_t>("i"_hs)
+            .data<&clazz::i, entt::as_ref_t>("i"_hs)
             .prop(3u, 0)
-            .data<&clazz_t::i, entt::as_cref_t>("ci"_hs)
-            .data<&clazz_t::j>("j"_hs)
+            .data<&clazz::i, entt::as_cref_t>("ci"_hs)
+            .data<&clazz::j>("j"_hs)
             .prop("true"_hs, 1)
-            .data<&clazz_t::h>("h"_hs)
-            .prop(static_cast<entt::id_type>(property_t::random), 2)
-            .data<&clazz_t::k>("k"_hs)
-            .prop(static_cast<entt::id_type>(property_t::value), 3)
-            .data<&clazz_t::base>("base"_hs)
-            .data<&clazz_t::i, entt::as_void_t>("void"_hs)
+            .data<&clazz::h>("h"_hs)
+            .prop(static_cast<entt::id_type>(property_type::random), 2)
+            .data<&clazz::k>("k"_hs)
+            .prop(static_cast<entt::id_type>(property_type::value), 3)
+            .data<&clazz::base>("base"_hs)
+            .data<&clazz::i, entt::as_void_t>("void"_hs)
             .conv<int>();
 
-        entt::meta<setter_getter_t>()
+        entt::meta<setter_getter>()
             .type("setter_getter"_hs)
-            .data<&setter_getter_t::static_setter, &setter_getter_t::static_getter>("x"_hs)
-            .data<&setter_getter_t::setter, &setter_getter_t::getter>("y"_hs)
-            .data<&setter_getter_t::static_setter, &setter_getter_t::getter>("z"_hs)
-            .data<&setter_getter_t::setter_with_ref, &setter_getter_t::getter_with_ref>("w"_hs)
-            .data<nullptr, &setter_getter_t::getter>("z_ro"_hs)
-            .data<nullptr, &setter_getter_t::value>("value"_hs);
-
-        entt::meta<multi_setter_t>()
+            .data<&setter_getter::static_setter, &setter_getter::static_getter>("x"_hs)
+            .data<&setter_getter::setter, &setter_getter::getter>("y"_hs)
+            .data<&setter_getter::static_setter, &setter_getter::getter>("z"_hs)
+            .data<&setter_getter::setter_with_ref, &setter_getter::getter_with_ref>("w"_hs)
+            .data<nullptr, &setter_getter::getter>("z_ro"_hs)
+            .data<nullptr, &setter_getter::value>("value"_hs);
+
+        entt::meta<multi_setter>()
             .type("multi_setter"_hs)
-            .data<entt::value_list<&multi_setter_t::from_double, &multi_setter_t::from_string>, &multi_setter_t::value>("value"_hs);
+            .data<entt::value_list<&multi_setter::from_double, &multi_setter::from_string>, &multi_setter::value>("value"_hs);
 
-        entt::meta<array_t>()
+        entt::meta<array>()
             .type("array"_hs)
-            .data<&array_t::global>("global"_hs)
-            .data<&array_t::local>("local"_hs);
+            .data<&array::global>("global"_hs)
+            .data<&array::local>("local"_hs);
 
-        base_t::counter = 0;
+        base::counter = 0;
     }
 
     void TearDown() override {
@@ -152,8 +152,8 @@ using MetaDataDeathTest = MetaData;
 TEST_F(MetaData, Functionalities) {
     using namespace entt::literals;
 
-    auto data = entt::resolve<clazz_t>().data("i"_hs);
-    clazz_t instance{};
+    auto data = entt::resolve<clazz>().data("i"_hs);
+    clazz instance{};
 
     ASSERT_TRUE(data);
 
@@ -188,8 +188,8 @@ TEST_F(MetaData, Functionalities) {
 TEST_F(MetaData, Const) {
     using namespace entt::literals;
 
-    auto data = entt::resolve<clazz_t>().data("j"_hs);
-    clazz_t instance{};
+    auto data = entt::resolve<clazz>().data("j"_hs);
+    clazz instance{};
 
     ASSERT_TRUE(data);
     ASSERT_EQ(data.arity(), 1u);
@@ -218,7 +218,7 @@ TEST_F(MetaData, Const) {
 TEST_F(MetaData, Static) {
     using namespace entt::literals;
 
-    auto data = entt::resolve<clazz_t>().data("h"_hs);
+    auto data = entt::resolve<clazz>().data("h"_hs);
 
     ASSERT_TRUE(data);
     ASSERT_EQ(data.arity(), 1u);
@@ -231,14 +231,14 @@ TEST_F(MetaData, Static) {
     ASSERT_EQ(data.get({}).cast<int>(), 1);
 
     for(auto curr: data.prop()) {
-        ASSERT_EQ(curr.first, static_cast<entt::id_type>(property_t::random));
+        ASSERT_EQ(curr.first, static_cast<entt::id_type>(property_type::random));
         ASSERT_EQ(curr.second.value(), 2);
     }
 
-    ASSERT_FALSE(data.prop(static_cast<entt::id_type>(property_t::value)));
+    ASSERT_FALSE(data.prop(static_cast<entt::id_type>(property_type::value)));
     ASSERT_FALSE(data.prop('c'));
 
-    auto prop = data.prop(static_cast<entt::id_type>(property_t::random));
+    auto prop = data.prop(static_cast<entt::id_type>(property_type::random));
 
     ASSERT_TRUE(prop);
     ASSERT_EQ(prop.value(), 2);
@@ -247,7 +247,7 @@ TEST_F(MetaData, Static) {
 TEST_F(MetaData, ConstStatic) {
     using namespace entt::literals;
 
-    auto data = entt::resolve<clazz_t>().data("k"_hs);
+    auto data = entt::resolve<clazz>().data("k"_hs);
 
     ASSERT_TRUE(data);
     ASSERT_EQ(data.arity(), 1u);
@@ -260,14 +260,14 @@ TEST_F(MetaData, ConstStatic) {
     ASSERT_EQ(data.get({}).cast<int>(), 3);
 
     for(auto curr: data.prop()) {
-        ASSERT_EQ(curr.first, static_cast<entt::id_type>(property_t::value));
+        ASSERT_EQ(curr.first, static_cast<entt::id_type>(property_type::value));
         ASSERT_EQ(curr.second.value(), 3);
     }
 
-    ASSERT_FALSE(data.prop(static_cast<entt::id_type>(property_t::random)));
+    ASSERT_FALSE(data.prop(static_cast<entt::id_type>(property_type::random)));
     ASSERT_FALSE(data.prop('c'));
 
-    auto prop = data.prop(static_cast<entt::id_type>(property_t::value));
+    auto prop = data.prop(static_cast<entt::id_type>(property_type::value));
 
     ASSERT_TRUE(prop);
     ASSERT_EQ(prop.value(), 3);
@@ -276,9 +276,9 @@ TEST_F(MetaData, ConstStatic) {
 TEST_F(MetaData, GetMetaAnyArg) {
     using namespace entt::literals;
 
-    entt::meta_any any{clazz_t{}};
-    any.cast<clazz_t &>().i = 3;
-    const auto value = entt::resolve<clazz_t>().data("i"_hs).get(any);
+    entt::meta_any any{clazz{}};
+    any.cast<clazz &>().i = 3;
+    const auto value = entt::resolve<clazz>().data("i"_hs).get(any);
 
     ASSERT_TRUE(value);
     ASSERT_TRUE(static_cast<bool>(value.cast<int>()));
@@ -289,86 +289,86 @@ TEST_F(MetaData, GetInvalidArg) {
     using namespace entt::literals;
 
     auto instance = 0;
-    ASSERT_FALSE(entt::resolve<clazz_t>().data("i"_hs).get(instance));
+    ASSERT_FALSE(entt::resolve<clazz>().data("i"_hs).get(instance));
 }
 
 TEST_F(MetaData, SetMetaAnyArg) {
     using namespace entt::literals;
 
-    entt::meta_any any{clazz_t{}};
+    entt::meta_any any{clazz{}};
     const entt::meta_any value{1};
 
-    ASSERT_EQ(any.cast<clazz_t>().i, 0);
-    ASSERT_TRUE(entt::resolve<clazz_t>().data("i"_hs).set(any, value));
-    ASSERT_EQ(any.cast<clazz_t>().i, 1);
+    ASSERT_EQ(any.cast<clazz>().i, 0);
+    ASSERT_TRUE(entt::resolve<clazz>().data("i"_hs).set(any, value));
+    ASSERT_EQ(any.cast<clazz>().i, 1);
 }
 
 TEST_F(MetaData, SetInvalidArg) {
     using namespace entt::literals;
 
-    ASSERT_FALSE(entt::resolve<clazz_t>().data("i"_hs).set({}, 'c'));
+    ASSERT_FALSE(entt::resolve<clazz>().data("i"_hs).set({}, 'c'));
 }
 
 TEST_F(MetaData, SetCast) {
     using namespace entt::literals;
 
-    clazz_t instance{};
+    clazz instance{};
 
-    ASSERT_EQ(base_t::counter, 0);
-    ASSERT_TRUE(entt::resolve<clazz_t>().data("base"_hs).set(instance, derived_t{}));
-    ASSERT_EQ(base_t::counter, 1);
+    ASSERT_EQ(base::counter, 0);
+    ASSERT_TRUE(entt::resolve<clazz>().data("base"_hs).set(instance, derived{}));
+    ASSERT_EQ(base::counter, 1);
 }
 
 TEST_F(MetaData, SetConvert) {
     using namespace entt::literals;
 
-    clazz_t instance{};
+    clazz instance{};
     instance.h = 1;
 
     ASSERT_EQ(instance.i, 0);
-    ASSERT_TRUE(entt::resolve<clazz_t>().data("i"_hs).set(instance, instance));
+    ASSERT_TRUE(entt::resolve<clazz>().data("i"_hs).set(instance, instance));
     ASSERT_EQ(instance.i, 1);
 }
 
 TEST_F(MetaData, SetByRef) {
     using namespace entt::literals;
 
-    entt::meta_any any{clazz_t{}};
+    entt::meta_any any{clazz{}};
     int value{1};
 
-    ASSERT_EQ(any.cast<clazz_t>().i, 0);
-    ASSERT_TRUE(entt::resolve<clazz_t>().data("i"_hs).set(any, entt::forward_as_meta(value)));
-    ASSERT_EQ(any.cast<clazz_t>().i, 1);
+    ASSERT_EQ(any.cast<clazz>().i, 0);
+    ASSERT_TRUE(entt::resolve<clazz>().data("i"_hs).set(any, entt::forward_as_meta(value)));
+    ASSERT_EQ(any.cast<clazz>().i, 1);
 
     value = 3;
     auto wrapper = entt::forward_as_meta(value);
 
-    ASSERT_TRUE(entt::resolve<clazz_t>().data("i"_hs).set(any, wrapper.as_ref()));
-    ASSERT_EQ(any.cast<clazz_t>().i, 3);
+    ASSERT_TRUE(entt::resolve<clazz>().data("i"_hs).set(any, wrapper.as_ref()));
+    ASSERT_EQ(any.cast<clazz>().i, 3);
 }
 
 TEST_F(MetaData, SetByConstRef) {
     using namespace entt::literals;
 
-    entt::meta_any any{clazz_t{}};
+    entt::meta_any any{clazz{}};
     int value{1};
 
-    ASSERT_EQ(any.cast<clazz_t>().i, 0);
-    ASSERT_TRUE(entt::resolve<clazz_t>().data("i"_hs).set(any, entt::forward_as_meta(std::as_const(value))));
-    ASSERT_EQ(any.cast<clazz_t>().i, 1);
+    ASSERT_EQ(any.cast<clazz>().i, 0);
+    ASSERT_TRUE(entt::resolve<clazz>().data("i"_hs).set(any, entt::forward_as_meta(std::as_const(value))));
+    ASSERT_EQ(any.cast<clazz>().i, 1);
 
     value = 3;
     auto wrapper = entt::forward_as_meta(std::as_const(value));
 
-    ASSERT_TRUE(entt::resolve<clazz_t>().data("i"_hs).set(any, wrapper.as_ref()));
-    ASSERT_EQ(any.cast<clazz_t>().i, 3);
+    ASSERT_TRUE(entt::resolve<clazz>().data("i"_hs).set(any, wrapper.as_ref()));
+    ASSERT_EQ(any.cast<clazz>().i, 3);
 }
 
 TEST_F(MetaData, SetterGetterAsFreeFunctions) {
     using namespace entt::literals;
 
-    auto data = entt::resolve<setter_getter_t>().data("x"_hs);
-    setter_getter_t instance{};
+    auto data = entt::resolve<setter_getter>().data("x"_hs);
+    setter_getter instance{};
 
     ASSERT_TRUE(data);
     ASSERT_EQ(data.arity(), 1u);
@@ -384,8 +384,8 @@ TEST_F(MetaData, SetterGetterAsFreeFunctions) {
 TEST_F(MetaData, SetterGetterAsMemberFunctions) {
     using namespace entt::literals;
 
-    auto data = entt::resolve<setter_getter_t>().data("y"_hs);
-    setter_getter_t instance{};
+    auto data = entt::resolve<setter_getter>().data("y"_hs);
+    setter_getter instance{};
 
     ASSERT_TRUE(data);
     ASSERT_EQ(data.arity(), 1u);
@@ -403,8 +403,8 @@ TEST_F(MetaData, SetterGetterAsMemberFunctions) {
 TEST_F(MetaData, SetterGetterWithRefAsMemberFunctions) {
     using namespace entt::literals;
 
-    auto data = entt::resolve<setter_getter_t>().data("w"_hs);
-    setter_getter_t instance{};
+    auto data = entt::resolve<setter_getter>().data("w"_hs);
+    setter_getter instance{};
 
     ASSERT_TRUE(data);
     ASSERT_EQ(data.arity(), 1u);
@@ -420,8 +420,8 @@ TEST_F(MetaData, SetterGetterWithRefAsMemberFunctions) {
 TEST_F(MetaData, SetterGetterMixed) {
     using namespace entt::literals;
 
-    auto data = entt::resolve<setter_getter_t>().data("z"_hs);
-    setter_getter_t instance{};
+    auto data = entt::resolve<setter_getter>().data("z"_hs);
+    setter_getter instance{};
 
     ASSERT_TRUE(data);
     ASSERT_EQ(data.arity(), 1u);
@@ -437,8 +437,8 @@ TEST_F(MetaData, SetterGetterMixed) {
 TEST_F(MetaData, SetterGetterReadOnly) {
     using namespace entt::literals;
 
-    auto data = entt::resolve<setter_getter_t>().data("z_ro"_hs);
-    setter_getter_t instance{};
+    auto data = entt::resolve<setter_getter>().data("z_ro"_hs);
+    setter_getter instance{};
 
     ASSERT_TRUE(data);
     ASSERT_EQ(data.arity(), 0u);
@@ -454,8 +454,8 @@ TEST_F(MetaData, SetterGetterReadOnly) {
 TEST_F(MetaData, SetterGetterReadOnlyDataMember) {
     using namespace entt::literals;
 
-    auto data = entt::resolve<setter_getter_t>().data("value"_hs);
-    setter_getter_t instance{};
+    auto data = entt::resolve<setter_getter>().data("value"_hs);
+    setter_getter instance{};
 
     ASSERT_TRUE(data);
     ASSERT_EQ(data.arity(), 0u);
@@ -471,8 +471,8 @@ TEST_F(MetaData, SetterGetterReadOnlyDataMember) {
 TEST_F(MetaData, MultiSetter) {
     using namespace entt::literals;
 
-    auto data = entt::resolve<multi_setter_t>().data("value"_hs);
-    multi_setter_t instance{};
+    auto data = entt::resolve<multi_setter>().data("value"_hs);
+    multi_setter instance{};
 
     ASSERT_TRUE(data);
     ASSERT_EQ(data.arity(), 2u);
@@ -495,34 +495,34 @@ TEST_F(MetaData, MultiSetter) {
 TEST_F(MetaData, ConstInstance) {
     using namespace entt::literals;
 
-    clazz_t instance{};
+    clazz instance{};
 
-    ASSERT_NE(entt::resolve<clazz_t>().data("i"_hs).get(instance).try_cast<int>(), nullptr);
-    ASSERT_NE(entt::resolve<clazz_t>().data("i"_hs).get(instance).try_cast<const int>(), nullptr);
-    ASSERT_EQ(entt::resolve<clazz_t>().data("i"_hs).get(std::as_const(instance)).try_cast<int>(), nullptr);
+    ASSERT_NE(entt::resolve<clazz>().data("i"_hs).get(instance).try_cast<int>(), nullptr);
+    ASSERT_NE(entt::resolve<clazz>().data("i"_hs).get(instance).try_cast<const int>(), nullptr);
+    ASSERT_EQ(entt::resolve<clazz>().data("i"_hs).get(std::as_const(instance)).try_cast<int>(), nullptr);
     // as_ref_t adapts to the constness of the passed object and returns const references in case
-    ASSERT_NE(entt::resolve<clazz_t>().data("i"_hs).get(std::as_const(instance)).try_cast<const int>(), nullptr);
-
-    ASSERT_TRUE(entt::resolve<clazz_t>().data("i"_hs).get(instance));
-    ASSERT_TRUE(entt::resolve<clazz_t>().data("i"_hs).set(instance, 3));
-    ASSERT_TRUE(entt::resolve<clazz_t>().data("i"_hs).get(std::as_const(instance)));
-    ASSERT_FALSE(entt::resolve<clazz_t>().data("i"_hs).set(std::as_const(instance), 3));
-
-    ASSERT_TRUE(entt::resolve<clazz_t>().data("ci"_hs).get(instance));
-    ASSERT_TRUE(entt::resolve<clazz_t>().data("ci"_hs).set(instance, 3));
-    ASSERT_TRUE(entt::resolve<clazz_t>().data("ci"_hs).get(std::as_const(instance)));
-    ASSERT_FALSE(entt::resolve<clazz_t>().data("ci"_hs).set(std::as_const(instance), 3));
-
-    ASSERT_TRUE(entt::resolve<clazz_t>().data("j"_hs).get(instance));
-    ASSERT_FALSE(entt::resolve<clazz_t>().data("j"_hs).set(instance, 3));
-    ASSERT_TRUE(entt::resolve<clazz_t>().data("j"_hs).get(std::as_const(instance)));
-    ASSERT_FALSE(entt::resolve<clazz_t>().data("j"_hs).set(std::as_const(instance), 3));
+    ASSERT_NE(entt::resolve<clazz>().data("i"_hs).get(std::as_const(instance)).try_cast<const int>(), nullptr);
+
+    ASSERT_TRUE(entt::resolve<clazz>().data("i"_hs).get(instance));
+    ASSERT_TRUE(entt::resolve<clazz>().data("i"_hs).set(instance, 3));
+    ASSERT_TRUE(entt::resolve<clazz>().data("i"_hs).get(std::as_const(instance)));
+    ASSERT_FALSE(entt::resolve<clazz>().data("i"_hs).set(std::as_const(instance), 3));
+
+    ASSERT_TRUE(entt::resolve<clazz>().data("ci"_hs).get(instance));
+    ASSERT_TRUE(entt::resolve<clazz>().data("ci"_hs).set(instance, 3));
+    ASSERT_TRUE(entt::resolve<clazz>().data("ci"_hs).get(std::as_const(instance)));
+    ASSERT_FALSE(entt::resolve<clazz>().data("ci"_hs).set(std::as_const(instance), 3));
+
+    ASSERT_TRUE(entt::resolve<clazz>().data("j"_hs).get(instance));
+    ASSERT_FALSE(entt::resolve<clazz>().data("j"_hs).set(instance, 3));
+    ASSERT_TRUE(entt::resolve<clazz>().data("j"_hs).get(std::as_const(instance)));
+    ASSERT_FALSE(entt::resolve<clazz>().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);
+    auto data = entt::resolve<array>().data("global"_hs);
 
     ASSERT_TRUE(data);
     ASSERT_EQ(data.arity(), 1u);
@@ -539,8 +539,8 @@ TEST_F(MetaData, ArrayStatic) {
 TEST_F(MetaData, Array) {
     using namespace entt::literals;
 
-    auto data = entt::resolve<array_t>().data("local"_hs);
-    array_t instance{};
+    auto data = entt::resolve<array>().data("local"_hs);
+    array instance{};
 
     ASSERT_TRUE(data);
     ASSERT_EQ(data.arity(), 1u);
@@ -557,8 +557,8 @@ TEST_F(MetaData, Array) {
 TEST_F(MetaData, AsVoid) {
     using namespace entt::literals;
 
-    auto data = entt::resolve<clazz_t>().data("void"_hs);
-    clazz_t instance{};
+    auto data = entt::resolve<clazz>().data("void"_hs);
+    clazz instance{};
 
     ASSERT_TRUE(data);
     ASSERT_EQ(data.arity(), 1u);
@@ -572,8 +572,8 @@ TEST_F(MetaData, AsVoid) {
 TEST_F(MetaData, AsRef) {
     using namespace entt::literals;
 
-    clazz_t instance{};
-    auto data = entt::resolve<clazz_t>().data("i"_hs);
+    clazz instance{};
+    auto data = entt::resolve<clazz>().data("i"_hs);
 
     ASSERT_TRUE(data);
     ASSERT_EQ(data.arity(), 1u);
@@ -590,8 +590,8 @@ TEST_F(MetaData, AsRef) {
 TEST_F(MetaData, AsConstRef) {
     using namespace entt::literals;
 
-    clazz_t instance{};
-    auto data = entt::resolve<clazz_t>().data("ci"_hs);
+    clazz instance{};
+    auto data = entt::resolve<clazz>().data("ci"_hs);
 
     ASSERT_EQ(instance.i, 0);
     ASSERT_EQ(data.arity(), 1u);
@@ -606,8 +606,8 @@ TEST_F(MetaData, AsConstRef) {
 ENTT_DEBUG_TEST_F(MetaDataDeathTest, AsConstRef) {
     using namespace entt::literals;
 
-    clazz_t instance{};
-    auto data = entt::resolve<clazz_t>().data("ci"_hs);
+    clazz instance{};
+    auto data = entt::resolve<clazz>().data("ci"_hs);
 
     ASSERT_DEATH(data.get(instance).cast<int &>() = 3, "");
 }
@@ -615,8 +615,8 @@ ENTT_DEBUG_TEST_F(MetaDataDeathTest, AsConstRef) {
 TEST_F(MetaData, SetGetBaseData) {
     using namespace entt::literals;
 
-    auto type = entt::resolve<derived_t>();
-    derived_t instance{};
+    auto type = entt::resolve<derived>();
+    derived instance{};
 
     ASSERT_TRUE(type.data("value"_hs));
 
@@ -629,8 +629,8 @@ TEST_F(MetaData, SetGetBaseData) {
 TEST_F(MetaData, SetGetFromBase) {
     using namespace entt::literals;
 
-    auto type = entt::resolve<derived_t>();
-    derived_t instance{};
+    auto type = entt::resolve<derived>();
+    derived instance{};
 
     ASSERT_TRUE(type.data("value_from_base"_hs));
 
@@ -645,15 +645,15 @@ TEST_F(MetaData, ReRegistration) {
 
     SetUp();
 
-    auto &&node = entt::internal::resolve<base_t>(entt::internal::meta_context::from(entt::locator<entt::meta_ctx>::value_or()));
-    auto type = entt::resolve<base_t>();
+    auto &&node = entt::internal::resolve<base>(entt::internal::meta_context::from(entt::locator<entt::meta_ctx>::value_or()));
+    auto type = entt::resolve<base>();
 
     ASSERT_TRUE(node.details);
     ASSERT_FALSE(node.details->data.empty());
     ASSERT_EQ(node.details->data.size(), 1u);
     ASSERT_TRUE(type.data("value"_hs));
 
-    entt::meta<base_t>().data<&base_t::value>("field"_hs);
+    entt::meta<base>().data<&base::value>("field"_hs);
 
     ASSERT_TRUE(node.details);
     ASSERT_EQ(node.details->data.size(), 2u);
@@ -664,14 +664,14 @@ TEST_F(MetaData, ReRegistration) {
 TEST_F(MetaData, CollisionAndReuse) {
     using namespace entt::literals;
 
-    ASSERT_TRUE(entt::resolve<clazz_t>().data("j"_hs));
-    ASSERT_FALSE(entt::resolve<clazz_t>().data("cj"_hs));
-    ASSERT_TRUE(entt::resolve<clazz_t>().data("j"_hs).is_const());
+    ASSERT_TRUE(entt::resolve<clazz>().data("j"_hs));
+    ASSERT_FALSE(entt::resolve<clazz>().data("cj"_hs));
+    ASSERT_TRUE(entt::resolve<clazz>().data("j"_hs).is_const());
 
-    ASSERT_NO_THROW(entt::meta<clazz_t>().data<&clazz_t::i>("j"_hs));
-    ASSERT_NO_THROW(entt::meta<clazz_t>().data<&clazz_t::j>("cj"_hs));
+    ASSERT_NO_THROW(entt::meta<clazz>().data<&clazz::i>("j"_hs));
+    ASSERT_NO_THROW(entt::meta<clazz>().data<&clazz::j>("cj"_hs));
 
-    ASSERT_TRUE(entt::resolve<clazz_t>().data("j"_hs));
-    ASSERT_TRUE(entt::resolve<clazz_t>().data("cj"_hs));
-    ASSERT_FALSE(entt::resolve<clazz_t>().data("j"_hs).is_const());
+    ASSERT_TRUE(entt::resolve<clazz>().data("j"_hs));
+    ASSERT_TRUE(entt::resolve<clazz>().data("cj"_hs));
+    ASSERT_FALSE(entt::resolve<clazz>().data("j"_hs).is_const());
 }

test/entt/meta/meta_dtor.cpp

@@ -8,13 +8,13 @@
 #include <entt/meta/node.hpp>
 #include <entt/meta/resolve.hpp>
 
-struct clazz_t {
-    clazz_t(int &cnt)
+struct clazz {
+    clazz(int &cnt)
         : counter{&cnt} {
         ++(*counter);
     }
 
-    static void destroy_decr(clazz_t &instance) {
+    static void destroy_decr(clazz &instance) {
         --(*instance.counter);
     }
 
@@ -29,10 +29,10 @@ struct MetaDtor: ::testing::Test {
     void SetUp() override {
         using namespace entt::literals;
 
-        entt::meta<clazz_t>()
+        entt::meta<clazz>()
             .type("clazz"_hs)
             .ctor<int &>()
-            .dtor<clazz_t::destroy_decr>();
+            .dtor<clazz::destroy_decr>();
     }
 
     void TearDown() override {
@@ -43,7 +43,7 @@ struct MetaDtor: ::testing::Test {
 TEST_F(MetaDtor, Functionalities) {
     int counter{};
 
-    auto any = entt::resolve<clazz_t>().construct(entt::forward_as_meta(counter));
+    auto any = entt::resolve<clazz>().construct(entt::forward_as_meta(counter));
     auto cref = std::as_const(any).as_ref();
     auto ref = any.as_ref();
 
@@ -74,7 +74,7 @@ TEST_F(MetaDtor, Functionalities) {
 TEST_F(MetaDtor, AsRefConstruction) {
     int counter{};
 
-    clazz_t instance{counter};
+    clazz instance{counter};
     auto any = entt::forward_as_meta(instance);
     auto cany = entt::forward_as_meta(std::as_const(instance));
     auto cref = cany.as_ref();
@@ -104,12 +104,12 @@ TEST_F(MetaDtor, ReRegistration) {
     SetUp();
 
     int counter{};
-    auto &&node = entt::internal::resolve<clazz_t>(entt::internal::meta_context::from(entt::locator<entt::meta_ctx>::value_or()));
+    auto &&node = entt::internal::resolve<clazz>(entt::internal::meta_context::from(entt::locator<entt::meta_ctx>::value_or()));
 
     ASSERT_NE(node.dtor.dtor, nullptr);
 
-    entt::meta<clazz_t>().dtor<&clazz_t::destroy_incr>();
-    entt::resolve<clazz_t>().construct(entt::forward_as_meta(counter)).reset();
+    entt::meta<clazz>().dtor<&clazz::destroy_incr>();
+    entt::resolve<clazz>().construct(entt::forward_as_meta(counter)).reset();
 
     ASSERT_EQ(counter, 2);
 }

test/entt/meta/meta_func.cpp

@@ -11,11 +11,11 @@
 #include <entt/meta/range.hpp>
 #include <entt/meta/resolve.hpp>
 
-struct base_t {
-    base_t() = default;
-    virtual ~base_t() = default;
+struct base {
+    base() = default;
+    virtual ~base() = default;
 
-    static void destroy(base_t &) {
+    static void destroy(base &) {
         ++counter;
     }
 
@@ -27,7 +27,7 @@ struct base_t {
         return value;
     }
 
-    static void static_setter(base_t &ref, int v) {
+    static void static_setter(base &ref, int v) {
         ref.value = v;
     }
 
@@ -35,21 +35,21 @@ struct base_t {
     int value{3};
 };
 
-void fake_member(base_t &instance, int value) {
+void fake_member(base &instance, int value) {
     instance.value = value;
 }
 
-[[nodiscard]] int fake_const_member(const base_t &instance) {
+[[nodiscard]] int fake_const_member(const base &instance) {
     return instance.value;
 }
 
-struct derived_t: base_t {
-    derived_t()
-        : base_t{} {}
+struct derived: base {
+    derived()
+        : base{} {}
 };
 
-struct func_t {
-    [[nodiscard]] int f(const base_t &, int a, int b) {
+struct function {
+    [[nodiscard]] int f(const base &, int a, int b) {
         return f(a, b);
     }
 
@@ -101,41 +101,41 @@ struct MetaFunc: ::testing::Test {
             .type("double"_hs)
             .func<&double_member>("member"_hs);
 
-        entt::meta<base_t>()
+        entt::meta<base>()
             .type("base"_hs)
-            .dtor<base_t::destroy>()
-            .func<&base_t::setter>("setter"_hs)
+            .dtor<base::destroy>()
+            .func<&base::setter>("setter"_hs)
             .func<fake_member>("fake_member"_hs)
             .func<fake_const_member>("fake_const_member"_hs);
 
-        entt::meta<derived_t>()
+        entt::meta<derived>()
             .type("derived"_hs)
-            .base<base_t>()
-            .func<&base_t::setter>("setter_from_base"_hs)
-            .func<&base_t::getter>("getter_from_base"_hs)
-            .func<&base_t::static_setter>("static_setter_from_base"_hs)
-            .dtor<derived_t::destroy>();
+            .base<base>()
+            .func<&base::setter>("setter_from_base"_hs)
+            .func<&base::getter>("getter_from_base"_hs)
+            .func<&base::static_setter>("static_setter_from_base"_hs)
+            .dtor<derived::destroy>();
 
-        entt::meta<func_t>()
+        entt::meta<function>()
             .type("func"_hs)
-            .func<&entt::registry::emplace_or_replace<func_t>>("emplace"_hs)
-            .func<entt::overload<int(const base_t &, int, int)>(&func_t::f)>("f3"_hs)
-            .func<entt::overload<int(int, int)>(&func_t::f)>("f2"_hs)
+            .func<&entt::registry::emplace_or_replace<function>>("emplace"_hs)
+            .func<entt::overload<int(const base &, int, int)>(&function::f)>("f3"_hs)
+            .func<entt::overload<int(int, int)>(&function::f)>("f2"_hs)
             .prop("true"_hs, false)
-            .func<entt::overload<int(int) const>(&func_t::f)>("f1"_hs)
+            .func<entt::overload<int(int) const>(&function::f)>("f1"_hs)
             .prop("true"_hs, false)
-            .func<&func_t::g>("g"_hs)
+            .func<&function::g>("g"_hs)
             .prop("true"_hs, false)
-            .func<func_t::h>("h"_hs)
+            .func<function::h>("h"_hs)
             .prop("true"_hs, false)
-            .func<func_t::k>("k"_hs)
+            .func<function::k>("k"_hs)
             .prop("true"_hs, false)
-            .func<&func_t::v, entt::as_void_t>("v"_hs)
-            .func<&func_t::a, entt::as_ref_t>("a"_hs)
-            .func<&func_t::a, entt::as_cref_t>("ca"_hs)
+            .func<&function::v, entt::as_void_t>("v"_hs)
+            .func<&function::a, entt::as_ref_t>("a"_hs)
+            .func<&function::a, entt::as_cref_t>("ca"_hs)
             .conv<int>();
 
-        base_t::counter = 0;
+        base::counter = 0;
     }
 
     void TearDown() override {
@@ -145,7 +145,7 @@ struct MetaFunc: ::testing::Test {
     std::size_t reset_and_check() {
         std::size_t count = 0;
 
-        for(auto func: entt::resolve<func_t>().func()) {
+        for(auto func: entt::resolve<function>().func()) {
             for(auto curr = func.second; curr; curr = curr.next()) {
                 ++count;
             }
@@ -153,7 +153,7 @@ struct MetaFunc: ::testing::Test {
 
         SetUp();
 
-        for(auto func: entt::resolve<func_t>().func()) {
+        for(auto func: entt::resolve<function>().func()) {
             for(auto curr = func.second; curr; curr = curr.next()) {
                 --count;
             }
@@ -168,8 +168,8 @@ using MetaFuncDeathTest = MetaFunc;
 TEST_F(MetaFunc, Functionalities) {
     using namespace entt::literals;
 
-    auto func = entt::resolve<func_t>().func("f2"_hs);
-    func_t instance{};
+    auto func = entt::resolve<function>().func("f2"_hs);
+    function instance{};
 
     ASSERT_TRUE(func);
 
@@ -193,7 +193,7 @@ TEST_F(MetaFunc, Functionalities) {
     ASSERT_TRUE(any);
     ASSERT_EQ(any.type(), entt::resolve<int>());
     ASSERT_EQ(any.cast<int>(), 4);
-    ASSERT_EQ(func_t::value, 3);
+    ASSERT_EQ(function::value, 3);
 
     for(auto curr: func.prop()) {
         ASSERT_EQ(curr.first, "true"_hs);
@@ -212,8 +212,8 @@ TEST_F(MetaFunc, Functionalities) {
 TEST_F(MetaFunc, Const) {
     using namespace entt::literals;
 
-    auto func = entt::resolve<func_t>().func("f1"_hs);
-    func_t instance{};
+    auto func = entt::resolve<function>().func("f1"_hs);
+    function instance{};
 
     ASSERT_TRUE(func);
     ASSERT_EQ(func.arity(), 1u);
@@ -224,7 +224,7 @@ TEST_F(MetaFunc, Const) {
     ASSERT_FALSE(func.arg(1u));
 
     auto any = func.invoke(instance, 4);
-    auto empty = func.invoke(instance, derived_t{});
+    auto empty = func.invoke(instance, derived{});
 
     ASSERT_FALSE(empty);
     ASSERT_TRUE(any);
@@ -248,8 +248,8 @@ TEST_F(MetaFunc, Const) {
 TEST_F(MetaFunc, RetVoid) {
     using namespace entt::literals;
 
-    auto func = entt::resolve<func_t>().func("g"_hs);
-    func_t instance{};
+    auto func = entt::resolve<function>().func("g"_hs);
+    function instance{};
 
     ASSERT_TRUE(func);
     ASSERT_EQ(func.arity(), 1u);
@@ -263,7 +263,7 @@ TEST_F(MetaFunc, RetVoid) {
 
     ASSERT_TRUE(any);
     ASSERT_EQ(any.type(), entt::resolve<void>());
-    ASSERT_EQ(func_t::value, 16);
+    ASSERT_EQ(function::value, 16);
 
     for(auto curr: func.prop()) {
         ASSERT_EQ(curr.first, "true"_hs);
@@ -282,8 +282,8 @@ TEST_F(MetaFunc, RetVoid) {
 TEST_F(MetaFunc, Static) {
     using namespace entt::literals;
 
-    auto func = entt::resolve<func_t>().func("h"_hs);
-    func_t::value = 2;
+    auto func = entt::resolve<function>().func("h"_hs);
+    function::value = 2;
 
     ASSERT_TRUE(func);
     ASSERT_EQ(func.arity(), 1u);
@@ -294,7 +294,7 @@ TEST_F(MetaFunc, Static) {
     ASSERT_FALSE(func.arg(1u));
 
     auto any = func.invoke({}, 3);
-    auto empty = func.invoke({}, derived_t{});
+    auto empty = func.invoke({}, derived{});
 
     ASSERT_FALSE(empty);
     ASSERT_TRUE(any);
@@ -318,7 +318,7 @@ TEST_F(MetaFunc, Static) {
 TEST_F(MetaFunc, StaticRetVoid) {
     using namespace entt::literals;
 
-    auto func = entt::resolve<func_t>().func("k"_hs);
+    auto func = entt::resolve<function>().func("k"_hs);
 
     ASSERT_TRUE(func);
     ASSERT_EQ(func.arity(), 1u);
@@ -332,7 +332,7 @@ TEST_F(MetaFunc, StaticRetVoid) {
 
     ASSERT_TRUE(any);
     ASSERT_EQ(any.type(), entt::resolve<void>());
-    ASSERT_EQ(func_t::value, 3);
+    ASSERT_EQ(function::value, 3);
 
     for(auto curr: func.prop()) {
         ASSERT_EQ(curr.first, "true"_hs);
@@ -351,8 +351,8 @@ TEST_F(MetaFunc, StaticRetVoid) {
 TEST_F(MetaFunc, StaticAsMember) {
     using namespace entt::literals;
 
-    base_t instance{};
-    auto func = entt::resolve<base_t>().func("fake_member"_hs);
+    base instance{};
+    auto func = entt::resolve<base>().func("fake_member"_hs);
     auto any = func.invoke(instance, 3);
 
     ASSERT_TRUE(func);
@@ -376,8 +376,8 @@ TEST_F(MetaFunc, StaticAsMember) {
 TEST_F(MetaFunc, StaticAsConstMember) {
     using namespace entt::literals;
 
-    base_t instance{};
-    auto func = entt::resolve<base_t>().func("fake_const_member"_hs);
+    base instance{};
+    auto func = entt::resolve<base>().func("fake_const_member"_hs);
     auto any = func.invoke(std::as_const(instance));
 
     ASSERT_TRUE(func);
@@ -424,8 +424,8 @@ TEST_F(MetaFunc, NonClassTypeMember) {
 TEST_F(MetaFunc, MetaAnyArgs) {
     using namespace entt::literals;
 
-    func_t instance;
-    auto any = entt::resolve<func_t>().func("f1"_hs).invoke(instance, 3);
+    function instance;
+    auto any = entt::resolve<function>().func("f1"_hs).invoke(instance, 3);
 
     ASSERT_TRUE(any);
     ASSERT_EQ(any.type(), entt::resolve<int>());
@@ -436,15 +436,15 @@ TEST_F(MetaFunc, InvalidArgs) {
     using namespace entt::literals;
 
     int value = 3;
-    ASSERT_FALSE(entt::resolve<func_t>().func("f1"_hs).invoke(value, 'c'));
+    ASSERT_FALSE(entt::resolve<function>().func("f1"_hs).invoke(value, 'c'));
 }
 
 TEST_F(MetaFunc, CastAndConvert) {
     using namespace entt::literals;
 
-    func_t instance;
+    function instance;
     instance.value = 3;
-    auto any = entt::resolve<func_t>().func("f3"_hs).invoke(instance, derived_t{}, 0, instance);
+    auto any = entt::resolve<function>().func("f3"_hs).invoke(instance, derived{}, 0, instance);
 
     ASSERT_TRUE(any);
     ASSERT_EQ(any.type(), entt::resolve<int>());
@@ -455,8 +455,8 @@ TEST_F(MetaFunc, CastAndConvert) {
 TEST_F(MetaFunc, ArithmeticConversion) {
     using namespace entt::literals;
 
-    func_t instance;
-    auto any = entt::resolve<func_t>().func("f2"_hs).invoke(instance, true, 4.2);
+    function instance;
+    auto any = entt::resolve<function>().func("f2"_hs).invoke(instance, true, 4.2);
 
     ASSERT_TRUE(any);
     ASSERT_EQ(any.type(), entt::resolve<int>());
@@ -467,8 +467,8 @@ TEST_F(MetaFunc, ArithmeticConversion) {
 TEST_F(MetaFunc, ArgsByRef) {
     using namespace entt::literals;
 
-    auto func = entt::resolve<func_t>().func("h"_hs);
-    func_t::value = 2;
+    auto func = entt::resolve<function>().func("h"_hs);
+    function::value = 2;
     entt::meta_any any{3};
     int value = 4;
 
@@ -481,25 +481,25 @@ TEST_F(MetaFunc, ArgsByRef) {
 TEST_F(MetaFunc, ArgsByConstRef) {
     using namespace entt::literals;
 
-    func_t instance{};
-    auto func = entt::resolve<func_t>().func("g"_hs);
+    function instance{};
+    auto func = entt::resolve<function>().func("g"_hs);
     entt::meta_any any{2};
     int value = 3;
 
     ASSERT_TRUE(func.invoke(instance, entt::forward_as_meta(std::as_const(value))));
-    ASSERT_EQ(func_t::value, 9);
+    ASSERT_EQ(function::value, 9);
 
     ASSERT_TRUE(func.invoke(instance, std::as_const(any).as_ref()));
-    ASSERT_EQ(func_t::value, 4);
+    ASSERT_EQ(function::value, 4);
 }
 
 TEST_F(MetaFunc, ConstInstance) {
     using namespace entt::literals;
 
-    func_t instance{};
-    auto any = entt::resolve<func_t>().func("f1"_hs).invoke(std::as_const(instance), 2);
+    function instance{};
+    auto any = entt::resolve<function>().func("f1"_hs).invoke(std::as_const(instance), 2);
 
-    ASSERT_FALSE(entt::resolve<func_t>().func("g"_hs).invoke(std::as_const(instance), 1));
+    ASSERT_FALSE(entt::resolve<function>().func("g"_hs).invoke(std::as_const(instance), 1));
     ASSERT_TRUE(any);
     ASSERT_EQ(any.cast<int>(), 4);
 }
@@ -507,8 +507,8 @@ TEST_F(MetaFunc, ConstInstance) {
 TEST_F(MetaFunc, AsVoid) {
     using namespace entt::literals;
 
-    auto func = entt::resolve<func_t>().func("v"_hs);
-    func_t instance{};
+    auto func = entt::resolve<function>().func("v"_hs);
+    function instance{};
 
     ASSERT_EQ(func.invoke(instance, 1), entt::meta_any{std::in_place_type<void>});
     ASSERT_EQ(func.ret(), entt::resolve<void>());
@@ -518,8 +518,8 @@ TEST_F(MetaFunc, AsVoid) {
 TEST_F(MetaFunc, AsRef) {
     using namespace entt::literals;
 
-    func_t instance{};
-    auto func = entt::resolve<func_t>().func("a"_hs);
+    function instance{};
+    auto func = entt::resolve<function>().func("a"_hs);
     func.invoke(instance).cast<int &>() = 3;
 
     ASSERT_EQ(func.ret(), entt::resolve<int>());
@@ -529,8 +529,8 @@ TEST_F(MetaFunc, AsRef) {
 TEST_F(MetaFunc, AsConstRef) {
     using namespace entt::literals;
 
-    func_t instance{};
-    auto func = entt::resolve<func_t>().func("ca"_hs);
+    function instance{};
+    auto func = entt::resolve<function>().func("ca"_hs);
 
     ASSERT_EQ(func.ret(), entt::resolve<int>());
     ASSERT_EQ(func.invoke(instance).cast<const int &>(), 3);
@@ -540,8 +540,8 @@ TEST_F(MetaFunc, AsConstRef) {
 ENTT_DEBUG_TEST_F(MetaFuncDeathTest, AsConstRef) {
     using namespace entt::literals;
 
-    func_t instance{};
-    auto func = entt::resolve<func_t>().func("ca"_hs);
+    function instance{};
+    auto func = entt::resolve<function>().func("ca"_hs);
 
     ASSERT_DEATH((func.invoke(instance).cast<int &>() = 3), "");
 }
@@ -549,8 +549,8 @@ ENTT_DEBUG_TEST_F(MetaFuncDeathTest, AsConstRef) {
 TEST_F(MetaFunc, InvokeBaseFunction) {
     using namespace entt::literals;
 
-    auto type = entt::resolve<derived_t>();
-    derived_t instance{};
+    auto type = entt::resolve<derived>();
+    derived instance{};
 
     ASSERT_TRUE(type.func("setter"_hs));
     ASSERT_EQ(instance.value, 3);
@@ -563,8 +563,8 @@ TEST_F(MetaFunc, InvokeBaseFunction) {
 TEST_F(MetaFunc, InvokeFromBase) {
     using namespace entt::literals;
 
-    auto type = entt::resolve<derived_t>();
-    derived_t instance{};
+    auto type = entt::resolve<derived>();
+    derived instance{};
 
     auto setter_from_base = type.func("setter_from_base"_hs);
 
@@ -593,7 +593,7 @@ TEST_F(MetaFunc, InvokeFromBase) {
 TEST_F(MetaFunc, ExternalMemberFunction) {
     using namespace entt::literals;
 
-    auto func = entt::resolve<func_t>().func("emplace"_hs);
+    auto func = entt::resolve<function>().func("emplace"_hs);
 
     ASSERT_TRUE(func);
     ASSERT_EQ(func.arity(), 2u);
@@ -607,11 +607,11 @@ TEST_F(MetaFunc, ExternalMemberFunction) {
     entt::registry registry;
     const auto entity = registry.create();
 
-    ASSERT_FALSE(registry.all_of<func_t>(entity));
+    ASSERT_FALSE(registry.all_of<function>(entity));
 
     func.invoke({}, entt::forward_as_meta(registry), entity);
 
-    ASSERT_TRUE(registry.all_of<func_t>(entity));
+    ASSERT_TRUE(registry.all_of<function>(entity));
 }
 
 TEST_F(MetaFunc, ReRegistration) {
@@ -619,8 +619,8 @@ TEST_F(MetaFunc, ReRegistration) {
 
     ASSERT_EQ(reset_and_check(), 0u);
 
-    func_t instance{};
-    auto type = entt::resolve<func_t>();
+    function instance{};
+    auto type = entt::resolve<function>();
 
     ASSERT_TRUE(type.func("f2"_hs));
     ASSERT_FALSE(type.invoke("f2"_hs, instance, 0));
@@ -630,9 +630,9 @@ TEST_F(MetaFunc, ReRegistration) {
     ASSERT_TRUE(type.invoke("f1"_hs, instance, 0));
     ASSERT_FALSE(type.invoke("f1"_hs, instance, 0, 0));
 
-    entt::meta<func_t>()
-        .func<entt::overload<int(int, int)>(&func_t::f)>("f"_hs)
-        .func<entt::overload<int(int) const>(&func_t::f)>("f"_hs);
+    entt::meta<function>()
+        .func<entt::overload<int(int, int)>(&function::f)>("f"_hs)
+        .func<entt::overload<int(int) const>(&function::f)>("f"_hs);
 
     ASSERT_TRUE(type.func("f1"_hs));
     ASSERT_TRUE(type.func("f2"_hs));

test/entt/meta/meta_handle.cpp

@@ -4,7 +4,7 @@
 #include <entt/meta/factory.hpp>
 #include <entt/meta/meta.hpp>
 
-struct clazz_t {
+struct clazz {
     void incr() {
         ++value;
     }
@@ -20,10 +20,10 @@ struct MetaHandle: ::testing::Test {
     void SetUp() override {
         using namespace entt::literals;
 
-        entt::meta<clazz_t>()
+        entt::meta<clazz>()
             .type("clazz"_hs)
-            .func<&clazz_t::incr>("incr"_hs)
-            .func<&clazz_t::decr>("decr"_hs);
+            .func<&clazz::incr>("incr"_hs)
+            .func<&clazz::decr>("decr"_hs);
     }
 
     void TearDown() override {
@@ -34,7 +34,7 @@ struct MetaHandle: ::testing::Test {
 TEST_F(MetaHandle, Functionalities) {
     using namespace entt::literals;
 
-    clazz_t instance{};
+    clazz instance{};
     entt::meta_handle handle{};
     entt::meta_handle chandle{};
 

test/entt/meta/meta_prop.cpp

@@ -8,34 +8,34 @@
 #include <entt/meta/meta.hpp>
 #include <entt/meta/resolve.hpp>
 
-struct base_1_t {};
-struct base_2_t {};
-struct base_3_t {};
-struct derived_t: base_1_t, base_2_t, base_3_t {};
+struct base_1 {};
+struct base_2 {};
+struct base_3 {};
+struct derived: base_1, base_2, base_3 {};
 
 struct MetaProp: ::testing::Test {
     void SetUp() override {
         using namespace entt::literals;
 
-        entt::meta<base_1_t>()
+        entt::meta<base_1>()
             .type("base_1"_hs)
             .prop("int"_hs, 2);
 
-        entt::meta<base_2_t>()
+        entt::meta<base_2>()
             .type("base_2"_hs)
             .prop("bool"_hs, false)
             .prop("char[]"_hs, "char[]");
 
-        entt::meta<base_3_t>()
+        entt::meta<base_3>()
             .type("base_3"_hs)
             .prop("key_only"_hs)
             .prop("key"_hs, 2);
 
-        entt::meta<derived_t>()
+        entt::meta<derived>()
             .type("derived"_hs)
-            .base<base_1_t>()
-            .base<base_2_t>()
-            .base<base_3_t>();
+            .base<base_1>()
+            .base<base_2>()
+            .base<base_3>();
     }
 
     void TearDown() override {
@@ -46,7 +46,7 @@ struct MetaProp: ::testing::Test {
 TEST_F(MetaProp, Functionalities) {
     using namespace entt::literals;
 
-    auto prop = entt::resolve<base_1_t>().prop("int"_hs);
+    auto prop = entt::resolve<base_1>().prop("int"_hs);
 
     ASSERT_TRUE(prop);
 
@@ -71,7 +71,7 @@ TEST_F(MetaProp, Functionalities) {
 TEST_F(MetaProp, FromBase) {
     using namespace entt::literals;
 
-    auto type = entt::resolve<derived_t>();
+    auto type = entt::resolve<derived>();
     auto prop_bool = type.prop("bool"_hs);
     auto prop_int = type.prop("int"_hs);
     auto key_only = type.prop("key_only"_hs);
@@ -91,7 +91,7 @@ TEST_F(MetaProp, FromBase) {
 TEST_F(MetaProp, DeducedArrayType) {
     using namespace entt::literals;
 
-    auto prop = entt::resolve<base_2_t>().prop("char[]"_hs);
+    auto prop = entt::resolve<base_2>().prop("char[]"_hs);
 
     ASSERT_TRUE(prop);
     ASSERT_EQ(prop.value().type(), entt::resolve<const char *>());
@@ -103,8 +103,8 @@ TEST_F(MetaProp, ReRegistration) {
 
     SetUp();
 
-    auto &&node = entt::internal::resolve<base_1_t>(entt::internal::meta_context::from(entt::locator<entt::meta_ctx>::value_or()));
-    auto type = entt::resolve<base_1_t>();
+    auto &&node = entt::internal::resolve<base_1>(entt::internal::meta_context::from(entt::locator<entt::meta_ctx>::value_or()));
+    auto type = entt::resolve<base_1>();
 
     ASSERT_TRUE(node.details);
     ASSERT_FALSE(node.details->prop.empty());
@@ -113,8 +113,8 @@ TEST_F(MetaProp, ReRegistration) {
     ASSERT_TRUE(type.prop("int"_hs));
     ASSERT_EQ(type.prop("int"_hs).value().cast<int>(), 2);
 
-    entt::meta<base_1_t>().prop("int"_hs, 0);
-    entt::meta<base_1_t>().prop("double"_hs, 3.);
+    entt::meta<base_1>().prop("int"_hs, 0);
+    entt::meta<base_1>().prop("double"_hs, 3.);
 
     ASSERT_TRUE(node.details);
     ASSERT_FALSE(node.details->prop.empty());

test/entt/meta/meta_type.cpp

@@ -29,35 +29,35 @@ Type get(Type &prop) {
     return prop;
 }
 
-struct base_t {
+struct base {
     char value{'c'};
 };
 
-struct derived_t: base_t {
-    derived_t()
-        : base_t{} {}
+struct derived: base {
+    derived()
+        : base{} {}
 };
 
-struct abstract_t {
-    virtual ~abstract_t() = default;
+struct abstract {
+    virtual ~abstract() = default;
 
     virtual void func(int) {}
     void base_only(int) {}
 };
 
-struct concrete_t: base_t, abstract_t {
+struct concrete: base, abstract {
     void func(int v) override {
-        abstract_t::func(v);
+        abstract::func(v);
         value = v;
     }
 
     int value{3};
 };
 
-struct clazz_t {
-    clazz_t() = default;
+struct clazz {
+    clazz() = default;
 
-    clazz_t(const base_t &, int v)
+    clazz(const base &, int v)
         : value{v} {}
 
     void member() {}
@@ -70,12 +70,12 @@ struct clazz_t {
     int value{};
 };
 
-struct overloaded_func_t {
+struct overloaded_func {
     [[nodiscard]] int e(int v) const {
         return v + v;
     }
 
-    [[nodiscard]] int f(const base_t &, int a, int b) {
+    [[nodiscard]] int f(const base &, int a, int b) {
         return f(a, b);
     }
 
@@ -104,7 +104,7 @@ struct overloaded_func_t {
     int value{};
 };
 
-enum class property_t : entt::id_type {
+enum class property_type : entt::id_type {
     random,
     value,
     key_only,
@@ -124,59 +124,59 @@ struct MetaType: ::testing::Test {
             .data<0u>("min"_hs)
             .data<128u>("max"_hs);
 
-        entt::meta<base_t>()
+        entt::meta<base>()
             .type("base"_hs)
-            .data<&base_t::value>("value"_hs);
+            .data<&base::value>("value"_hs);
 
-        entt::meta<derived_t>()
+        entt::meta<derived>()
             .type("derived"_hs)
-            .base<base_t>();
+            .base<base>();
 
-        entt::meta<abstract_t>()
+        entt::meta<abstract>()
             .type("abstract"_hs)
-            .func<&abstract_t::func>("func"_hs)
-            .func<&abstract_t::base_only>("base_only"_hs);
+            .func<&abstract::func>("func"_hs)
+            .func<&abstract::base_only>("base_only"_hs);
 
-        entt::meta<concrete_t>()
+        entt::meta<concrete>()
             .type("concrete"_hs)
-            .base<base_t>()
-            .base<abstract_t>();
+            .base<base>()
+            .base<abstract>();
 
-        entt::meta<overloaded_func_t>()
+        entt::meta<overloaded_func>()
             .type("overloaded_func"_hs)
-            .func<&overloaded_func_t::e>("e"_hs)
-            .func<entt::overload<int(const base_t &, int, int)>(&overloaded_func_t::f)>("f"_hs)
-            .func<entt::overload<int(int, int)>(&overloaded_func_t::f)>("f"_hs)
-            .func<entt::overload<int(int)>(&overloaded_func_t::f)>("f"_hs)
-            .func<entt::overload<int(int) const>(&overloaded_func_t::f)>("f"_hs)
-            .func<entt::overload<float(int, float)>(&overloaded_func_t::f)>("f"_hs)
-            .func<&overloaded_func_t::g>("g"_hs);
-
-        entt::meta<property_t>()
+            .func<&overloaded_func::e>("e"_hs)
+            .func<entt::overload<int(const base &, int, int)>(&overloaded_func::f)>("f"_hs)
+            .func<entt::overload<int(int, int)>(&overloaded_func::f)>("f"_hs)
+            .func<entt::overload<int(int)>(&overloaded_func::f)>("f"_hs)
+            .func<entt::overload<int(int) const>(&overloaded_func::f)>("f"_hs)
+            .func<entt::overload<float(int, float)>(&overloaded_func::f)>("f"_hs)
+            .func<&overloaded_func::g>("g"_hs);
+
+        entt::meta<property_type>()
             .type("property"_hs)
-            .data<property_t::random>("random"_hs)
-            .prop(static_cast<entt::id_type>(property_t::random), 0)
-            .prop(static_cast<entt::id_type>(property_t::value), 3)
-            .data<property_t::value>("value"_hs)
-            .prop(static_cast<entt::id_type>(property_t::random), true)
-            .prop(static_cast<entt::id_type>(property_t::value), 0)
-            .prop(static_cast<entt::id_type>(property_t::key_only))
-            .prop(static_cast<entt::id_type>(property_t::list))
-            .data<property_t::key_only>("key_only"_hs)
-            .prop(static_cast<entt::id_type>(property_t::key_only))
-            .data<property_t::list>("list"_hs)
-            .prop(static_cast<entt::id_type>(property_t::random), false)
-            .prop(static_cast<entt::id_type>(property_t::value), 0)
-            .prop(static_cast<entt::id_type>(property_t::key_only))
-            .data<set<property_t>, get<property_t>>("var"_hs);
-
-        entt::meta<clazz_t>()
+            .data<property_type::random>("random"_hs)
+            .prop(static_cast<entt::id_type>(property_type::random), 0)
+            .prop(static_cast<entt::id_type>(property_type::value), 3)
+            .data<property_type::value>("value"_hs)
+            .prop(static_cast<entt::id_type>(property_type::random), true)
+            .prop(static_cast<entt::id_type>(property_type::value), 0)
+            .prop(static_cast<entt::id_type>(property_type::key_only))
+            .prop(static_cast<entt::id_type>(property_type::list))
+            .data<property_type::key_only>("key_only"_hs)
+            .prop(static_cast<entt::id_type>(property_type::key_only))
+            .data<property_type::list>("list"_hs)
+            .prop(static_cast<entt::id_type>(property_type::random), false)
+            .prop(static_cast<entt::id_type>(property_type::value), 0)
+            .prop(static_cast<entt::id_type>(property_type::key_only))
+            .data<set<property_type>, get<property_type>>("var"_hs);
+
+        entt::meta<clazz>()
             .type("clazz"_hs)
-            .prop(static_cast<entt::id_type>(property_t::value), 3)
-            .ctor<const base_t &, int>()
-            .data<&clazz_t::value>("value"_hs)
-            .func<&clazz_t::member>("member"_hs)
-            .func<clazz_t::func>("func"_hs)
+            .prop(static_cast<entt::id_type>(property_type::value), 3)
+            .ctor<const base &, int>()
+            .data<&clazz::value>("value"_hs)
+            .func<&clazz::member>("member"_hs)
+            .func<clazz::func>("func"_hs)
             .conv<int>();
     }
 
@@ -199,7 +199,7 @@ TEST_F(MetaType, Resolve) {
     const auto it = std::find_if(range.begin(), range.end(), [](auto curr) { return curr.second.id() == entt::hashed_string::value("clazz"); });
 
     ASSERT_NE(it, range.end());
-    ASSERT_EQ(it->second, entt::resolve<clazz_t>());
+    ASSERT_EQ(it->second, entt::resolve<clazz>());
 
     bool found = false;
 
@@ -213,22 +213,22 @@ TEST_F(MetaType, Resolve) {
 TEST_F(MetaType, Functionalities) {
     using namespace entt::literals;
 
-    auto type = entt::resolve<clazz_t>();
+    auto type = entt::resolve<clazz>();
 
     ASSERT_TRUE(type);
     ASSERT_NE(type, entt::meta_type{});
     ASSERT_EQ(type.id(), "clazz"_hs);
-    ASSERT_EQ(type.info(), entt::type_id<clazz_t>());
+    ASSERT_EQ(type.info(), entt::type_id<clazz>());
 
     for(auto &&curr: type.prop()) {
-        ASSERT_EQ(curr.first, static_cast<entt::id_type>(property_t::value));
+        ASSERT_EQ(curr.first, static_cast<entt::id_type>(property_type::value));
         ASSERT_EQ(curr.second.value(), 3);
     }
 
-    ASSERT_FALSE(type.prop(static_cast<entt::id_type>(property_t::key_only)));
+    ASSERT_FALSE(type.prop(static_cast<entt::id_type>(property_type::key_only)));
     ASSERT_FALSE(type.prop("property"_hs));
 
-    auto prop = type.prop(static_cast<entt::id_type>(property_t::value));
+    auto prop = type.prop(static_cast<entt::id_type>(property_type::value));
 
     ASSERT_TRUE(prop);
     ASSERT_EQ(prop.value(), 3);
@@ -246,15 +246,15 @@ TEST_F(MetaType, SizeOf) {
 TEST_F(MetaType, Traits) {
     ASSERT_TRUE(entt::resolve<bool>().is_arithmetic());
     ASSERT_TRUE(entt::resolve<double>().is_arithmetic());
-    ASSERT_FALSE(entt::resolve<clazz_t>().is_arithmetic());
+    ASSERT_FALSE(entt::resolve<clazz>().is_arithmetic());
 
     ASSERT_TRUE(entt::resolve<int>().is_integral());
     ASSERT_FALSE(entt::resolve<double>().is_integral());
-    ASSERT_FALSE(entt::resolve<clazz_t>().is_integral());
+    ASSERT_FALSE(entt::resolve<clazz>().is_integral());
 
     ASSERT_TRUE(entt::resolve<long>().is_signed());
     ASSERT_FALSE(entt::resolve<unsigned int>().is_signed());
-    ASSERT_FALSE(entt::resolve<clazz_t>().is_signed());
+    ASSERT_FALSE(entt::resolve<clazz>().is_signed());
 
     // NOLINTBEGIN(*-avoid-c-arrays)
     ASSERT_TRUE(entt::resolve<int[5]>().is_array());
@@ -262,10 +262,10 @@ TEST_F(MetaType, Traits) {
     // NOLINTEND(*-avoid-c-arrays)
     ASSERT_FALSE(entt::resolve<int>().is_array());
 
-    ASSERT_TRUE(entt::resolve<property_t>().is_enum());
+    ASSERT_TRUE(entt::resolve<property_type>().is_enum());
     ASSERT_FALSE(entt::resolve<char>().is_enum());
 
-    ASSERT_TRUE(entt::resolve<derived_t>().is_class());
+    ASSERT_TRUE(entt::resolve<derived>().is_class());
     ASSERT_FALSE(entt::resolve<double>().is_class());
 
     ASSERT_TRUE(entt::resolve<int *>().is_pointer());
@@ -288,7 +288,7 @@ TEST_F(MetaType, RemovePointer) {
     ASSERT_EQ(entt::resolve<void *>().remove_pointer(), entt::resolve<void>());
     ASSERT_EQ(entt::resolve<char **>().remove_pointer(), entt::resolve<char *>());
     ASSERT_EQ(entt::resolve<int (*)(char, double)>().remove_pointer(), entt::resolve<int(char, double)>());
-    ASSERT_EQ(entt::resolve<derived_t>().remove_pointer(), entt::resolve<derived_t>());
+    ASSERT_EQ(entt::resolve<derived>().remove_pointer(), entt::resolve<derived>());
 }
 
 TEST_F(MetaType, TemplateInfo) {
@@ -305,61 +305,61 @@ TEST_F(MetaType, TemplateInfo) {
 }
 
 TEST_F(MetaType, CanCast) {
-    auto type = entt::resolve<derived_t>();
+    auto type = entt::resolve<derived>();
 
     ASSERT_FALSE(type.can_cast(entt::resolve<void>()));
-    ASSERT_TRUE(type.can_cast(entt::resolve<base_t>()));
-    ASSERT_TRUE(type.can_cast(entt::resolve<derived_t>()));
+    ASSERT_TRUE(type.can_cast(entt::resolve<base>()));
+    ASSERT_TRUE(type.can_cast(entt::resolve<derived>()));
 }
 
 TEST_F(MetaType, CanConvert) {
-    auto clazz = entt::resolve<clazz_t>();
-    auto derived = entt::resolve<derived_t>();
+    auto instance = entt::resolve<clazz>();
+    auto other = entt::resolve<derived>();
     auto arithmetic = entt::resolve<int>();
 
-    ASSERT_TRUE(clazz.can_convert(entt::resolve<clazz_t>()));
-    ASSERT_TRUE(clazz.can_convert(entt::resolve<int>()));
+    ASSERT_TRUE(instance.can_convert(entt::resolve<clazz>()));
+    ASSERT_TRUE(instance.can_convert(entt::resolve<int>()));
 
-    ASSERT_TRUE(derived.can_convert(entt::resolve<derived_t>()));
-    ASSERT_TRUE(derived.can_convert(entt::resolve<base_t>()));
-    ASSERT_FALSE(derived.can_convert(entt::resolve<int>()));
+    ASSERT_TRUE(other.can_convert(entt::resolve<derived>()));
+    ASSERT_TRUE(other.can_convert(entt::resolve<base>()));
+    ASSERT_FALSE(other.can_convert(entt::resolve<int>()));
 
     ASSERT_TRUE(arithmetic.can_convert(entt::resolve<int>()));
-    ASSERT_FALSE(arithmetic.can_convert(entt::resolve<clazz_t>()));
+    ASSERT_FALSE(arithmetic.can_convert(entt::resolve<clazz>()));
     ASSERT_TRUE(arithmetic.can_convert(entt::resolve<double>()));
     ASSERT_TRUE(arithmetic.can_convert(entt::resolve<float>()));
 }
 
 TEST_F(MetaType, Base) {
-    auto type = entt::resolve<derived_t>();
+    auto type = entt::resolve<derived>();
 
     ASSERT_NE(type.base().cbegin(), type.base().cend());
 
     for(auto curr: type.base()) {
-        ASSERT_EQ(curr.first, entt::type_id<base_t>().hash());
-        ASSERT_EQ(curr.second, entt::resolve<base_t>());
+        ASSERT_EQ(curr.first, entt::type_id<base>().hash());
+        ASSERT_EQ(curr.second, entt::resolve<base>());
     }
 }
 
 TEST_F(MetaType, Ctor) {
-    derived_t derived;
-    base_t &base = derived;
-    auto type = entt::resolve<clazz_t>();
+    derived instance;
+    base &as_base = instance;
+    auto type = entt::resolve<clazz>();
 
-    ASSERT_TRUE((type.construct(entt::forward_as_meta(derived), 3)));
-    ASSERT_TRUE((type.construct(entt::forward_as_meta(base), 3)));
+    ASSERT_TRUE((type.construct(entt::forward_as_meta(instance), 3)));
+    ASSERT_TRUE((type.construct(entt::forward_as_meta(as_base), 3)));
 
     // use the implicitly generated default constructor
     auto any = type.construct();
 
     ASSERT_TRUE(any);
-    ASSERT_EQ(any.type(), entt::resolve<clazz_t>());
+    ASSERT_EQ(any.type(), entt::resolve<clazz>());
 }
 
 TEST_F(MetaType, Data) {
     using namespace entt::literals;
 
-    auto type = entt::resolve<clazz_t>();
+    auto type = entt::resolve<clazz>();
     int counter{};
 
     for([[maybe_unused]] auto &&curr: type.data()) {
@@ -378,8 +378,8 @@ TEST_F(MetaType, Data) {
 TEST_F(MetaType, Func) {
     using namespace entt::literals;
 
-    auto type = entt::resolve<clazz_t>();
-    clazz_t instance{};
+    auto type = entt::resolve<clazz>();
+    clazz instance{};
     int counter{};
 
     for([[maybe_unused]] auto &&curr: type.func()) {
@@ -401,8 +401,8 @@ TEST_F(MetaType, Func) {
 TEST_F(MetaType, Invoke) {
     using namespace entt::literals;
 
-    auto type = entt::resolve<clazz_t>();
-    clazz_t instance{};
+    auto type = entt::resolve<clazz>();
+    clazz instance{};
 
     ASSERT_TRUE(type.invoke("member"_hs, instance));
     ASSERT_FALSE(type.invoke("rebmem"_hs, instance));
@@ -414,8 +414,8 @@ TEST_F(MetaType, Invoke) {
 TEST_F(MetaType, InvokeFromBase) {
     using namespace entt::literals;
 
-    auto type = entt::resolve<concrete_t>();
-    concrete_t instance{};
+    auto type = entt::resolve<concrete>();
+    concrete instance{};
 
     ASSERT_TRUE(type.invoke("base_only"_hs, instance, 3));
     ASSERT_FALSE(type.invoke("ylno_esab"_hs, {}, 'c'));
@@ -424,15 +424,15 @@ TEST_F(MetaType, InvokeFromBase) {
 TEST_F(MetaType, OverloadedFunc) {
     using namespace entt::literals;
 
-    const auto type = entt::resolve<overloaded_func_t>();
-    overloaded_func_t instance{};
+    const auto type = entt::resolve<overloaded_func>();
+    overloaded_func instance{};
     entt::meta_any res{};
 
     ASSERT_TRUE(type.func("f"_hs));
     ASSERT_TRUE(type.func("e"_hs));
     ASSERT_TRUE(type.func("g"_hs));
 
-    res = type.invoke("f"_hs, instance, base_t{}, 1, 2);
+    res = type.invoke("f"_hs, instance, base{}, 1, 2);
 
     ASSERT_TRUE(res);
     ASSERT_EQ(instance.value, 1);
@@ -479,46 +479,46 @@ TEST_F(MetaType, OverloadedFunc) {
 }
 
 TEST_F(MetaType, Construct) {
-    auto any = entt::resolve<clazz_t>().construct(base_t{}, 2);
+    auto any = entt::resolve<clazz>().construct(base{}, 2);
 
     ASSERT_TRUE(any);
-    ASSERT_EQ(any.cast<clazz_t>().value, 2);
+    ASSERT_EQ(any.cast<clazz>().value, 2);
 }
 
 TEST_F(MetaType, ConstructNoArgs) {
     // this should work, no other tests required
-    auto any = entt::resolve<clazz_t>().construct();
+    auto any = entt::resolve<clazz>().construct();
 
     ASSERT_TRUE(any);
 }
 
 TEST_F(MetaType, ConstructMetaAnyArgs) {
-    auto any = entt::resolve<clazz_t>().construct(entt::meta_any{base_t{}}, entt::meta_any{3});
+    auto any = entt::resolve<clazz>().construct(entt::meta_any{base{}}, entt::meta_any{3});
 
     ASSERT_TRUE(any);
-    ASSERT_EQ(any.cast<clazz_t>().value, 3);
+    ASSERT_EQ(any.cast<clazz>().value, 3);
 }
 
 TEST_F(MetaType, ConstructInvalidArgs) {
-    ASSERT_FALSE(entt::resolve<clazz_t>().construct('c', base_t{}));
+    ASSERT_FALSE(entt::resolve<clazz>().construct('c', base{}));
 }
 
 TEST_F(MetaType, LessArgs) {
-    ASSERT_FALSE(entt::resolve<clazz_t>().construct(base_t{}));
+    ASSERT_FALSE(entt::resolve<clazz>().construct(base{}));
 }
 
 TEST_F(MetaType, ConstructCastAndConvert) {
-    auto any = entt::resolve<clazz_t>().construct(derived_t{}, clazz_t{derived_t{}, 3});
+    auto any = entt::resolve<clazz>().construct(derived{}, clazz{derived{}, 3});
 
     ASSERT_TRUE(any);
-    ASSERT_EQ(any.cast<clazz_t>().value, 3);
+    ASSERT_EQ(any.cast<clazz>().value, 3);
 }
 
 TEST_F(MetaType, ConstructArithmeticConversion) {
-    auto any = entt::resolve<clazz_t>().construct(derived_t{}, clazz_t{derived_t{}, true});
+    auto any = entt::resolve<clazz>().construct(derived{}, clazz{derived{}, true});
 
     ASSERT_TRUE(any);
-    ASSERT_EQ(any.cast<clazz_t>().value, 1);
+    ASSERT_EQ(any.cast<clazz>().value, 1);
 }
 
 TEST_F(MetaType, FromVoid) {
@@ -554,24 +554,24 @@ TEST_F(MetaType, Reset) {
     using namespace entt::literals;
 
     ASSERT_TRUE(entt::resolve("clazz"_hs));
-    ASSERT_EQ(entt::resolve<clazz_t>().id(), "clazz"_hs);
-    ASSERT_TRUE(entt::resolve<clazz_t>().prop(static_cast<entt::id_type>(property_t::value)));
-    ASSERT_TRUE(entt::resolve<clazz_t>().data("value"_hs));
-    ASSERT_TRUE((entt::resolve<clazz_t>().construct(derived_t{}, clazz_t{})));
+    ASSERT_EQ(entt::resolve<clazz>().id(), "clazz"_hs);
+    ASSERT_TRUE(entt::resolve<clazz>().prop(static_cast<entt::id_type>(property_type::value)));
+    ASSERT_TRUE(entt::resolve<clazz>().data("value"_hs));
+    ASSERT_TRUE((entt::resolve<clazz>().construct(derived{}, clazz{})));
     // implicitly generated default constructor
-    ASSERT_TRUE(entt::resolve<clazz_t>().construct());
+    ASSERT_TRUE(entt::resolve<clazz>().construct());
 
     entt::meta_reset("clazz"_hs);
 
     ASSERT_FALSE(entt::resolve("clazz"_hs));
-    ASSERT_NE(entt::resolve<clazz_t>().id(), "clazz"_hs);
-    ASSERT_FALSE(entt::resolve<clazz_t>().prop(static_cast<entt::id_type>(property_t::value)));
-    ASSERT_FALSE(entt::resolve<clazz_t>().data("value"_hs));
-    ASSERT_FALSE((entt::resolve<clazz_t>().construct(derived_t{}, clazz_t{})));
+    ASSERT_NE(entt::resolve<clazz>().id(), "clazz"_hs);
+    ASSERT_FALSE(entt::resolve<clazz>().prop(static_cast<entt::id_type>(property_type::value)));
+    ASSERT_FALSE(entt::resolve<clazz>().data("value"_hs));
+    ASSERT_FALSE((entt::resolve<clazz>().construct(derived{}, clazz{})));
     // implicitly generated default constructor is not cleared
-    ASSERT_TRUE(entt::resolve<clazz_t>().construct());
+    ASSERT_TRUE(entt::resolve<clazz>().construct());
 
-    entt::meta<clazz_t>().type("clazz"_hs);
+    entt::meta<clazz>().type("clazz"_hs);
 
     ASSERT_TRUE(entt::resolve("clazz"_hs));
 }
@@ -607,23 +607,23 @@ TEST_F(MetaType, ResetAll) {
 TEST_F(MetaType, AbstractClass) {
     using namespace entt::literals;
 
-    auto type = entt::resolve<abstract_t>();
-    concrete_t instance;
+    auto type = entt::resolve<abstract>();
+    concrete instance;
 
-    ASSERT_EQ(type.info(), entt::type_id<abstract_t>());
-    ASSERT_EQ(instance.base_t::value, 'c');
+    ASSERT_EQ(type.info(), entt::type_id<abstract>());
+    ASSERT_EQ(instance.base::value, 'c');
     ASSERT_EQ(instance.value, 3);
 
     type.func("func"_hs).invoke(instance, 2);
 
-    ASSERT_EQ(instance.base_t::value, 'c');
+    ASSERT_EQ(instance.base::value, 'c');
     ASSERT_EQ(instance.value, 2);
 }
 
 TEST_F(MetaType, EnumAndNamedConstants) {
     using namespace entt::literals;
 
-    auto type = entt::resolve<property_t>();
+    auto type = entt::resolve<property_type>();
 
     ASSERT_TRUE(type.data("random"_hs));
     ASSERT_TRUE(type.data("value"_hs));
@@ -631,11 +631,11 @@ TEST_F(MetaType, EnumAndNamedConstants) {
     ASSERT_EQ(type.data("random"_hs).type(), type);
     ASSERT_EQ(type.data("value"_hs).type(), type);
 
-    ASSERT_FALSE(type.data("random"_hs).set({}, property_t::value));
-    ASSERT_FALSE(type.data("value"_hs).set({}, property_t::random));
+    ASSERT_FALSE(type.data("random"_hs).set({}, property_type::value));
+    ASSERT_FALSE(type.data("value"_hs).set({}, property_type::random));
 
-    ASSERT_EQ(type.data("random"_hs).get({}).cast<property_t>(), property_t::random);
-    ASSERT_EQ(type.data("value"_hs).get({}).cast<property_t>(), property_t::value);
+    ASSERT_EQ(type.data("random"_hs).get({}).cast<property_type>(), property_type::random);
+    ASSERT_EQ(type.data("value"_hs).get({}).cast<property_type>(), property_type::value);
 }
 
 TEST_F(MetaType, ArithmeticTypeAndNamedConstants) {
@@ -659,43 +659,43 @@ TEST_F(MetaType, ArithmeticTypeAndNamedConstants) {
 TEST_F(MetaType, Variables) {
     using namespace entt::literals;
 
-    auto p_data = entt::resolve<property_t>().data("var"_hs);
+    auto p_data = entt::resolve<property_type>().data("var"_hs);
     auto d_data = entt::resolve("double"_hs).data("var"_hs);
 
-    property_t prop{property_t::key_only};
+    property_type prop{property_type::key_only};
     double d = 3.;
 
-    p_data.set(prop, property_t::random);
+    p_data.set(prop, property_type::random);
     d_data.set(d, 3.);
 
-    ASSERT_EQ(p_data.get(prop).cast<property_t>(), property_t::random);
+    ASSERT_EQ(p_data.get(prop).cast<property_type>(), property_type::random);
     ASSERT_EQ(d_data.get(d).cast<double>(), 3.);
-    ASSERT_EQ(prop, property_t::random);
+    ASSERT_EQ(prop, property_type::random);
     ASSERT_EQ(d, 3.);
 }
 
 TEST_F(MetaType, PropertiesAndCornerCases) {
     using namespace entt::literals;
 
-    auto type = entt::resolve<property_t>();
+    auto type = entt::resolve<property_type>();
 
     ASSERT_EQ(type.prop().cbegin(), type.prop().cend());
 
-    ASSERT_EQ(type.data("random"_hs).prop(static_cast<entt::id_type>(property_t::random)).value().cast<int>(), 0);
-    ASSERT_EQ(type.data("random"_hs).prop(static_cast<entt::id_type>(property_t::value)).value().cast<int>(), 3);
+    ASSERT_EQ(type.data("random"_hs).prop(static_cast<entt::id_type>(property_type::random)).value().cast<int>(), 0);
+    ASSERT_EQ(type.data("random"_hs).prop(static_cast<entt::id_type>(property_type::value)).value().cast<int>(), 3);
 
-    ASSERT_EQ(type.data("value"_hs).prop(static_cast<entt::id_type>(property_t::random)).value().cast<bool>(), true);
-    ASSERT_EQ(type.data("value"_hs).prop(static_cast<entt::id_type>(property_t::value)).value().cast<int>(), 0);
-    ASSERT_TRUE(type.data("value"_hs).prop(static_cast<entt::id_type>(property_t::key_only)));
-    ASSERT_FALSE(type.data("value"_hs).prop(static_cast<entt::id_type>(property_t::key_only)).value());
+    ASSERT_EQ(type.data("value"_hs).prop(static_cast<entt::id_type>(property_type::random)).value().cast<bool>(), true);
+    ASSERT_EQ(type.data("value"_hs).prop(static_cast<entt::id_type>(property_type::value)).value().cast<int>(), 0);
+    ASSERT_TRUE(type.data("value"_hs).prop(static_cast<entt::id_type>(property_type::key_only)));
+    ASSERT_FALSE(type.data("value"_hs).prop(static_cast<entt::id_type>(property_type::key_only)).value());
 
-    ASSERT_TRUE(type.data("key_only"_hs).prop(static_cast<entt::id_type>(property_t::key_only)));
-    ASSERT_FALSE(type.data("key_only"_hs).prop(static_cast<entt::id_type>(property_t::key_only)).value());
+    ASSERT_TRUE(type.data("key_only"_hs).prop(static_cast<entt::id_type>(property_type::key_only)));
+    ASSERT_FALSE(type.data("key_only"_hs).prop(static_cast<entt::id_type>(property_type::key_only)).value());
 
-    ASSERT_EQ(type.data("list"_hs).prop(static_cast<entt::id_type>(property_t::random)).value().cast<bool>(), false);
-    ASSERT_EQ(type.data("list"_hs).prop(static_cast<entt::id_type>(property_t::value)).value().cast<int>(), 0);
-    ASSERT_TRUE(type.data("list"_hs).prop(static_cast<entt::id_type>(property_t::key_only)));
-    ASSERT_FALSE(type.data("list"_hs).prop(static_cast<entt::id_type>(property_t::key_only)).value());
+    ASSERT_EQ(type.data("list"_hs).prop(static_cast<entt::id_type>(property_type::random)).value().cast<bool>(), false);
+    ASSERT_EQ(type.data("list"_hs).prop(static_cast<entt::id_type>(property_type::value)).value().cast<int>(), 0);
+    ASSERT_TRUE(type.data("list"_hs).prop(static_cast<entt::id_type>(property_type::key_only)));
+    ASSERT_FALSE(type.data("list"_hs).prop(static_cast<entt::id_type>(property_type::key_only)).value());
 
     type = entt::resolve<void>();
 
@@ -709,13 +709,13 @@ TEST_F(MetaType, ResetAndReRegistrationAfterReset) {
 
     entt::meta_reset<double>();
     entt::meta_reset<unsigned int>();
-    entt::meta_reset<base_t>();
-    entt::meta_reset<derived_t>();
-    entt::meta_reset<abstract_t>();
-    entt::meta_reset<concrete_t>();
-    entt::meta_reset<overloaded_func_t>();
-    entt::meta_reset<property_t>();
-    entt::meta_reset<clazz_t>();
+    entt::meta_reset<base>();
+    entt::meta_reset<derived>();
+    entt::meta_reset<abstract>();
+    entt::meta_reset<concrete>();
+    entt::meta_reset<overloaded_func>();
+    entt::meta_reset<property_type>();
+    entt::meta_reset<clazz>();
 
     ASSERT_FALSE(entt::resolve("double"_hs));
     ASSERT_FALSE(entt::resolve("base"_hs));
@@ -724,11 +724,11 @@ TEST_F(MetaType, ResetAndReRegistrationAfterReset) {
 
     ASSERT_TRUE(entt::internal::meta_context::from(entt::locator<entt::meta_ctx>::value_or()).value.empty());
 
-    ASSERT_FALSE(entt::resolve<clazz_t>().prop(static_cast<entt::id_type>(property_t::value)));
+    ASSERT_FALSE(entt::resolve<clazz>().prop(static_cast<entt::id_type>(property_type::value)));
     // implicitly generated default constructor is not cleared
-    ASSERT_TRUE(entt::resolve<clazz_t>().construct());
-    ASSERT_FALSE(entt::resolve<clazz_t>().data("value"_hs));
-    ASSERT_FALSE(entt::resolve<clazz_t>().func("member"_hs));
+    ASSERT_TRUE(entt::resolve<clazz>().construct());
+    ASSERT_FALSE(entt::resolve<clazz>().data("value"_hs));
+    ASSERT_FALSE(entt::resolve<clazz>().func("member"_hs));
 
     entt::meta<double>().type("double"_hs);
     entt::meta_any any{3.};
@@ -740,14 +740,14 @@ TEST_F(MetaType, ResetAndReRegistrationAfterReset) {
     ASSERT_FALSE(entt::resolve("derived"_hs));
     ASSERT_TRUE(entt::resolve("double"_hs));
 
-    entt::meta<property_t>()
+    entt::meta<property_type>()
         .type("property"_hs)
-        .data<property_t::random>("rand"_hs)
-        .prop(static_cast<entt::id_type>(property_t::value), 3)
-        .prop(static_cast<entt::id_type>(property_t::random), 3);
+        .data<property_type::random>("rand"_hs)
+        .prop(static_cast<entt::id_type>(property_type::value), 3)
+        .prop(static_cast<entt::id_type>(property_type::random), 3);
 
-    ASSERT_TRUE(entt::resolve<property_t>().data("rand"_hs).prop(static_cast<entt::id_type>(property_t::value)));
-    ASSERT_TRUE(entt::resolve<property_t>().data("rand"_hs).prop(static_cast<entt::id_type>(property_t::random)));
+    ASSERT_TRUE(entt::resolve<property_type>().data("rand"_hs).prop(static_cast<entt::id_type>(property_type::value)));
+    ASSERT_TRUE(entt::resolve<property_type>().data("rand"_hs).prop(static_cast<entt::id_type>(property_type::random)));
 }
 
 TEST_F(MetaType, ReRegistration) {
@@ -778,10 +778,10 @@ TEST_F(MetaType, ReRegistration) {
 TEST_F(MetaType, NameCollision) {
     using namespace entt::literals;
 
-    ASSERT_NO_THROW(entt::meta<clazz_t>().type("clazz"_hs));
+    ASSERT_NO_THROW(entt::meta<clazz>().type("clazz"_hs));
     ASSERT_TRUE(entt::resolve("clazz"_hs));
 
-    ASSERT_NO_THROW(entt::meta<clazz_t>().type("quux"_hs));
+    ASSERT_NO_THROW(entt::meta<clazz>().type("quux"_hs));
     ASSERT_FALSE(entt::resolve("clazz"_hs));
     ASSERT_TRUE(entt::resolve("quux"_hs));
 }
@@ -789,5 +789,5 @@ TEST_F(MetaType, NameCollision) {
 ENTT_DEBUG_TEST_F(MetaTypeDeathTest, NameCollision) {
     using namespace entt::literals;
 
-    ASSERT_DEATH(entt::meta<clazz_t>().type("abstract"_hs), "");
+    ASSERT_DEATH(entt::meta<clazz>().type("abstract"_hs), "");
 }