test: use meta_factory<T> instead of meta<T>

test/entt/meta/meta_any.cpp

@@ -89,16 +89,16 @@ struct MetaAny: ::testing::Test {
     void SetUp() override {
         using namespace entt::literals;
 
-        entt::meta<empty>()
+        entt::meta_factory<empty>{}
             .type("empty"_hs)
             .dtor<empty::destroy>();
 
-        entt::meta<fat>()
+        entt::meta_factory<fat>{}
             .type("fat"_hs)
             .base<empty>()
             .dtor<fat::destroy>();
 
-        entt::meta<clazz>()
+        entt::meta_factory<clazz>{}
             .type("clazz"_hs)
             .data<&clazz::value>("value"_hs)
             .func<&clazz::member>("member"_hs)

test/entt/meta/meta_base.cpp

@@ -37,18 +37,18 @@ struct MetaBase: ::testing::Test {
     void SetUp() override {
         using namespace entt::literals;
 
-        entt::meta<base_1>()
+        entt::meta_factory<base_1>{}
             .data<&base_1::value_1>("value_1"_hs);
 
-        entt::meta<base_2>()
+        entt::meta_factory<base_2>{}
             .conv<int>()
             .data<&base_2::value_2>("value_2"_hs);
 
-        entt::meta<base_3>()
+        entt::meta_factory<base_3>{}
             .base<base_2>()
             .data<&base_3::value_3>("value_3"_hs);
 
-        entt::meta<derived>()
+        entt::meta_factory<derived>{}
             .type("derived"_hs)
             .base<base_1>()
             .base<base_3>()

test/entt/meta/meta_context.cpp

@@ -78,13 +78,13 @@ class MetaContext: public ::testing::Test {
     static void init_global_context() {
         using namespace entt::literals;
 
-        entt::meta<int>()
+        entt::meta_factory<int>{}
             .data<global_marker>("marker"_hs);
 
-        entt::meta<argument>()
+        entt::meta_factory<argument>{}
             .conv<&argument::get>();
 
-        entt::meta<clazz>()
+        entt::meta_factory<clazz>{}
             .type("foo"_hs)
             .custom<int>(3)
             .ctor<int>()
@@ -92,27 +92,27 @@ class MetaContext: public ::testing::Test {
             .data<&clazz::value>("rw"_hs)
             .func<&clazz::func>("func"_hs);
 
-        entt::meta<template_clazz<int>>()
+        entt::meta_factory<template_clazz<int>>{}
             .type("template"_hs);
     }
 
     void init_local_context() {
         using namespace entt::literals;
 
-        entt::meta<int>(context)
+        entt::meta_factory<int>{context}
             .data<local_marker>("marker"_hs);
 
-        entt::meta<test::empty>(context)
+        entt::meta_factory<test::empty>{context}
             .type("quux"_hs);
 
-        entt::meta<argument>(context)
+        entt::meta_factory<argument>{context}
             .conv<&argument::get_mul>();
 
-        entt::meta<base>(context)
+        entt::meta_factory<base>{context}
             .data<&base::value>("char"_hs)
             .func<&base::get>("get"_hs);
 
-        entt::meta<clazz>(context)
+        entt::meta_factory<clazz>{context}
             .type("bar"_hs)
             .custom<char>('c')
             .base<base>()
@@ -122,7 +122,7 @@ class MetaContext: public ::testing::Test {
             .data<&clazz::value>("rw"_hs)
             .func<&clazz::cfunc>("func"_hs);
 
-        entt::meta<template_clazz<int, char>>(context)
+        entt::meta_factory<template_clazz<int, char>>{context}
             .type("template"_hs);
     }
 

test/entt/meta/meta_conv.cpp

@@ -30,7 +30,7 @@ struct MetaConv: ::testing::Test {
     void SetUp() override {
         using namespace entt::literals;
 
-        entt::meta<clazz>()
+        entt::meta_factory<clazz>{}
             .type("clazz"_hs)
             .conv<int>()
             .conv<&clazz::to_bool>()

test/entt/meta/meta_ctor.cpp

@@ -50,15 +50,15 @@ struct MetaCtor: ::testing::Test {
     void SetUp() override {
         using namespace entt::literals;
 
-        entt::meta<double>()
+        entt::meta_factory<double>{}
             .type("double"_hs)
             .ctor<double_factory>();
 
-        entt::meta<derived>()
+        entt::meta_factory<derived>{}
             .type("derived"_hs)
             .base<base>();
 
-        entt::meta<clazz>()
+        entt::meta_factory<clazz>{}
             .type("clazz"_hs)
             .ctor<&entt::registry::emplace_or_replace<clazz, const int &, const char &>, entt::as_ref_t>()
             .ctor<const base &, int &>()

test/entt/meta/meta_custom.cpp

@@ -22,7 +22,7 @@ struct MetaCustom: ::testing::Test {
     void SetUp() override {
         using namespace entt::literals;
 
-        entt::meta<clazz>()
+        entt::meta_factory<clazz>{}
             .type("clazz"_hs)
             .custom<char>('c')
             .data<&clazz::i>("i"_hs)
@@ -132,7 +132,7 @@ TEST_F(MetaCustom, ReRegistration) {
     ASSERT_NE(static_cast<const char *>(type.custom()), nullptr);
     ASSERT_EQ(*static_cast<const char *>(type.custom()), 'c');
 
-    entt::meta<clazz>().custom<int>(1);
+    entt::meta_factory<clazz>{}.custom<int>(1);
     type = entt::resolve<clazz>();
 
     ASSERT_NE(static_cast<const int *>(type.custom()), nullptr);

test/entt/meta/meta_data.cpp

@@ -91,18 +91,18 @@ struct MetaData: ::testing::Test {
     void SetUp() override {
         using namespace entt::literals;
 
-        entt::meta<base>()
+        entt::meta_factory<base>{}
             .type("base"_hs)
             .dtor<base::destroy>()
             .data<&base::value>("value"_hs);
 
-        entt::meta<derived>()
+        entt::meta_factory<derived>{}
             .type("derived"_hs)
             .base<base>()
             .dtor<derived::destroy>()
             .data<&base::value>("value_from_base"_hs);
 
-        entt::meta<clazz>()
+        entt::meta_factory<clazz>{}
             .type("clazz"_hs)
             .data<&clazz::i, entt::as_ref_t>("i"_hs)
             .custom<char>('c')
@@ -118,7 +118,7 @@ struct MetaData: ::testing::Test {
             .data<&clazz::i, entt::as_void_t>("void"_hs)
             .conv<int>();
 
-        entt::meta<setter_getter>()
+        entt::meta_factory<setter_getter>{}
             .type("setter_getter"_hs)
             .data<&setter_getter::static_setter, &setter_getter::static_getter>("x"_hs)
             .data<&setter_getter::setter, &setter_getter::getter>("y"_hs)
@@ -127,11 +127,11 @@ struct MetaData: ::testing::Test {
             .data<nullptr, &setter_getter::getter>("z_ro"_hs)
             .data<nullptr, &setter_getter::value>("value"_hs);
 
-        entt::meta<multi_setter>()
+        entt::meta_factory<multi_setter>{}
             .type("multi_setter"_hs)
             .data<entt::value_list<&multi_setter::from_double, &multi_setter::from_string>, &multi_setter::value>("value"_hs);
 
-        entt::meta<array>()
+        entt::meta_factory<array>{}
             .type("array"_hs)
             .data<&array::global>("global"_hs)
             .data<&array::local>("local"_hs);
@@ -163,7 +163,7 @@ ENTT_DEBUG_TEST_F(MetaDataDeathTest, UserTraits) {
 
     using traits_type = entt::internal::meta_traits;
     constexpr auto value = traits_type{static_cast<std::underlying_type_t<traits_type>>(traits_type::_user_defined_traits) + 1u};
-    ASSERT_DEATH(entt::meta<clazz>().data<&clazz::i>("j"_hs).traits(value), "");
+    ASSERT_DEATH(entt::meta_factory<clazz>{}.data<&clazz::i>("j"_hs).traits(value), "");
 }
 
 TEST_F(MetaData, Custom) {
@@ -640,14 +640,14 @@ TEST_F(MetaData, ReRegistration) {
     ASSERT_EQ(node.details->data.size(), 1u);
     ASSERT_TRUE(type.data("value"_hs));
 
-    entt::meta<base>().data<&base::value>("field"_hs);
+    entt::meta_factory<base>{}.data<&base::value>("field"_hs);
 
     ASSERT_TRUE(node.details);
     ASSERT_EQ(node.details->data.size(), 2u);
     ASSERT_TRUE(type.data("value"_hs));
     ASSERT_TRUE(type.data("field"_hs));
 
-    entt::meta<base>()
+    entt::meta_factory<base>{}
         .data<&base::value>("field"_hs)
         .traits(test::meta_traits::one)
         .custom<int>(3)
@@ -665,8 +665,8 @@ TEST_F(MetaData, CollisionAndReuse) {
     ASSERT_FALSE(entt::resolve<clazz>().data("cj"_hs));
     ASSERT_TRUE(entt::resolve<clazz>().data("j"_hs).is_const());
 
-    ASSERT_NO_THROW(entt::meta<clazz>().data<&clazz::i>("j"_hs));
-    ASSERT_NO_THROW(entt::meta<clazz>().data<&clazz::j>("cj"_hs));
+    ASSERT_NO_THROW(entt::meta_factory<clazz>{}.data<&clazz::i>("j"_hs));
+    ASSERT_NO_THROW(entt::meta_factory<clazz>{}.data<&clazz::j>("cj"_hs));
 
     ASSERT_TRUE(entt::resolve<clazz>().data("j"_hs));
     ASSERT_TRUE(entt::resolve<clazz>().data("cj"_hs));

test/entt/meta/meta_dtor.cpp

@@ -29,7 +29,7 @@ struct MetaDtor: ::testing::Test {
     void SetUp() override {
         using namespace entt::literals;
 
-        entt::meta<clazz>()
+        entt::meta_factory<clazz>{}
             .type("clazz"_hs)
             .ctor<int &>()
             .dtor<clazz::destroy_decr>();
@@ -108,7 +108,7 @@ TEST_F(MetaDtor, ReRegistration) {
 
     ASSERT_NE(node.dtor.dtor, nullptr);
 
-    entt::meta<clazz>().dtor<&clazz::destroy_incr>();
+    entt::meta_factory<clazz>{}.dtor<&clazz::destroy_incr>();
     entt::resolve<clazz>().construct(entt::forward_as_meta(counter)).reset();
 
     ASSERT_EQ(counter, 2);

test/entt/meta/meta_factory.cpp

@@ -79,23 +79,19 @@ TEST_F(MetaFactory, Constructors) {
 
     ASSERT_NE(entt::resolve(entt::type_id<int>()), entt::meta_type{});
     ASSERT_EQ(entt::resolve(ctx, entt::type_id<int>()), entt::meta_type{});
-
-    // this is because of entt::meta, which should be deprecated nowadays
-    ASSERT_FALSE(entt::resolve(entt::type_id<int>()).is_integral());
+    ASSERT_TRUE(entt::resolve(entt::type_id<int>()).is_integral());
 
     factory = entt::meta_factory<int>{ctx};
 
     ASSERT_NE(entt::resolve(entt::type_id<int>()), entt::meta_type{});
     ASSERT_NE(entt::resolve(ctx, entt::type_id<int>()), entt::meta_type{});
-
-    // this is because of entt::meta, which should be deprecated nowadays
-    ASSERT_FALSE(entt::resolve(ctx, entt::type_id<int>()).is_integral());
+    ASSERT_TRUE(entt::resolve(ctx, entt::type_id<int>()).is_integral());
 }
 
 TEST_F(MetaFactory, Type) {
     using namespace entt::literals;
 
-    auto factory = entt::meta<int>();
+    entt::meta_factory<int> factory{};
 
     ASSERT_EQ(entt::resolve("foo"_hs), entt::meta_type{});
 
@@ -114,8 +110,8 @@ TEST_F(MetaFactory, Type) {
 ENTT_DEBUG_TEST_F(MetaFactoryDeathTest, Type) {
     using namespace entt::literals;
 
-    auto factory = entt::meta<int>();
-    auto other = entt::meta<double>();
+    entt::meta_factory<int> factory{};
+    entt::meta_factory<double> other{};
 
     factory.type("foo"_hs);
 
@@ -123,7 +119,7 @@ ENTT_DEBUG_TEST_F(MetaFactoryDeathTest, Type) {
 }
 
 TEST_F(MetaFactory, Base) {
-    auto factory = entt::meta<clazz>();
+    entt::meta_factory<clazz> factory{};
     decltype(std::declval<entt::meta_type>().base()) range{};
 
     ASSERT_NE(entt::resolve(entt::type_id<clazz>()), entt::meta_type{});
@@ -145,7 +141,7 @@ TEST_F(MetaFactory, Base) {
 
 TEST_F(MetaFactory, Conv) {
     const clazz instance{3};
-    auto factory = entt::meta<clazz>();
+    entt::meta_factory<clazz> factory{};
     const entt::meta_any any = entt::forward_as_meta(instance);
 
     ASSERT_FALSE(any.allow_cast<int>());
@@ -161,7 +157,7 @@ TEST_F(MetaFactory, Conv) {
 
 TEST_F(MetaFactory, Ctor) {
     const std::array values{1, 3};
-    auto factory = entt::meta<clazz>();
+    entt::meta_factory<clazz> factory{};
 
     ASSERT_FALSE(entt::resolve<clazz>().construct(values[0u]));
     ASSERT_FALSE(entt::resolve<clazz>().construct(std::to_string(values[1u])));
@@ -181,7 +177,7 @@ TEST_F(MetaFactory, Ctor) {
 
 TEST_F(MetaFactory, Dtor) {
     bool check = false;
-    auto factory = entt::meta<dtor_callback>();
+    entt::meta_factory<dtor_callback> factory{};
     entt::meta_any any{std::in_place_type<dtor_callback>, check};
 
     any.reset();
@@ -199,7 +195,7 @@ TEST_F(MetaFactory, DataMemberObject) {
     using namespace entt::literals;
 
     base instance{'c'};
-    auto factory = entt::meta<base>();
+    entt::meta_factory<base> factory{};
     entt::meta_type type = entt::resolve<base>();
 
     ASSERT_FALSE(type.data("member"_hs));
@@ -217,7 +213,7 @@ TEST_F(MetaFactory, DataMemberObject) {
 TEST_F(MetaFactory, DataPointer) {
     using namespace entt::literals;
 
-    auto factory = entt::meta<int>();
+    entt::meta_factory<int> factory{};
     entt::meta_type type = entt::resolve<int>();
 
     ASSERT_FALSE(type.data("value"_hs));
@@ -235,7 +231,7 @@ TEST_F(MetaFactory, DataValue) {
     using namespace entt::literals;
 
     constexpr int value = 1;
-    auto factory = entt::meta<int>();
+    entt::meta_factory<int> factory{};
     entt::meta_type type = entt::resolve<int>();
 
     ASSERT_FALSE(type.data("value"_hs));
@@ -252,7 +248,7 @@ TEST_F(MetaFactory, DataGetterOnly) {
     using namespace entt::literals;
 
     clazz instance{1};
-    auto factory = entt::meta<clazz>();
+    entt::meta_factory<clazz> factory{};
     entt::meta_type type = entt::resolve<clazz>();
 
     ASSERT_FALSE(type.data("value"_hs));
@@ -271,7 +267,7 @@ TEST_F(MetaFactory, DataSetterGetter) {
     using namespace entt::literals;
 
     clazz instance{1};
-    auto factory = entt::meta<clazz>();
+    entt::meta_factory<clazz> factory{};
     entt::meta_type type = entt::resolve<clazz>();
 
     ASSERT_FALSE(type.data("value"_hs));
@@ -290,7 +286,7 @@ TEST_F(MetaFactory, DataMultiSetterGetter) {
     using namespace entt::literals;
 
     clazz instance{1};
-    auto factory = entt::meta<clazz>();
+    entt::meta_factory<clazz> factory{};
     entt::meta_type type = entt::resolve<clazz>();
 
     ASSERT_FALSE(type.data("value"_hs));
@@ -310,7 +306,7 @@ TEST_F(MetaFactory, DataMultiSetterGetter) {
 TEST_F(MetaFactory, DataOverwrite) {
     using namespace entt::literals;
 
-    auto factory = entt::meta<clazz>();
+    entt::meta_factory<clazz> factory{};
     entt::meta_type type = entt::resolve<clazz>();
 
     ASSERT_FALSE(type.data("value"_hs));
@@ -332,7 +328,7 @@ TEST_F(MetaFactory, Func) {
     using namespace entt::literals;
 
     const clazz instance{1};
-    auto factory = entt::meta<clazz>();
+    entt::meta_factory<clazz> factory{};
     entt::meta_type type = entt::resolve<clazz>();
 
     ASSERT_FALSE(type.func("func"_hs));
@@ -350,7 +346,7 @@ TEST_F(MetaFactory, FuncOverload) {
     using namespace entt::literals;
 
     clazz instance{1};
-    auto factory = entt::meta<clazz>();
+    entt::meta_factory<clazz> factory{};
     entt::meta_type type = entt::resolve<clazz>();
 
     ASSERT_FALSE(type.func("func"_hs));
@@ -376,7 +372,7 @@ TEST_F(MetaFactory, FuncOverload) {
 TEST_F(MetaFactory, Traits) {
     using namespace entt::literals;
 
-    entt::meta<clazz>()
+    entt::meta_factory<clazz>{}
         .data<&base::member>("member"_hs)
         .func<&clazz::set_int>("func"_hs)
         .func<&clazz::set_boxed_int>("func"_hs);
@@ -388,7 +384,7 @@ TEST_F(MetaFactory, Traits) {
     ASSERT_EQ(type.func("func"_hs).traits<test::meta_traits>(), test::meta_traits::none);
     ASSERT_EQ(type.func("func"_hs).next().traits<test::meta_traits>(), test::meta_traits::none);
 
-    entt::meta<clazz>()
+    entt::meta_factory<clazz>{}
         .traits(test::meta_traits::one | test::meta_traits::three)
         .data<&base::member>("member"_hs)
         .traits(test::meta_traits::one)
@@ -409,7 +405,7 @@ TEST_F(MetaFactory, Traits) {
 TEST_F(MetaFactory, Custom) {
     using namespace entt::literals;
 
-    entt::meta<clazz>()
+    entt::meta_factory<clazz>{}
         .data<&base::member>("member"_hs)
         .func<&clazz::set_int>("func"_hs)
         .func<&clazz::set_boxed_int>("func"_hs);
@@ -421,7 +417,7 @@ TEST_F(MetaFactory, Custom) {
     ASSERT_EQ(static_cast<const int *>(type.func("func"_hs).custom()), nullptr);
     ASSERT_EQ(static_cast<const int *>(type.func("func"_hs).next().custom()), nullptr);
 
-    entt::meta<clazz>()
+    entt::meta_factory<clazz>{}
         .custom<int>(0)
         .data<&base::member>("member"_hs)
         .custom<int>(1)
@@ -463,8 +459,8 @@ TEST_F(MetaFactory, MetaReset) {
 
     entt::meta_ctx ctx{};
 
-    entt::meta<int>().type("global"_hs);
-    entt::meta<int>(ctx).type("local"_hs);
+    entt::meta_factory<int>{}.type("global"_hs);
+    entt::meta_factory<int>{ctx}.type("local"_hs);
 
     ASSERT_TRUE(entt::resolve(entt::type_id<int>()));
     ASSERT_TRUE(entt::resolve(ctx, entt::type_id<int>()));
@@ -479,8 +475,8 @@ TEST_F(MetaFactory, MetaReset) {
     ASSERT_FALSE(entt::resolve(entt::type_id<int>()));
     ASSERT_FALSE(entt::resolve(ctx, entt::type_id<int>()));
 
-    entt::meta<int>().type("global"_hs);
-    entt::meta<int>(ctx).type("local"_hs);
+    entt::meta_factory<int>{}.type("global"_hs);
+    entt::meta_factory<int>{ctx}.type("local"_hs);
 
     ASSERT_TRUE(entt::resolve(entt::type_id<int>()));
     ASSERT_TRUE(entt::resolve(ctx, entt::type_id<int>()));
@@ -495,8 +491,8 @@ TEST_F(MetaFactory, MetaReset) {
     ASSERT_FALSE(entt::resolve(entt::type_id<int>()));
     ASSERT_FALSE(entt::resolve(ctx, entt::type_id<int>()));
 
-    entt::meta<int>().type("global"_hs);
-    entt::meta<int>(ctx).type("local"_hs);
+    entt::meta_factory<int>{}.type("global"_hs);
+    entt::meta_factory<int>{ctx}.type("local"_hs);
 
     ASSERT_TRUE(entt::resolve(entt::type_id<int>()));
     ASSERT_TRUE(entt::resolve(ctx, entt::type_id<int>()));

test/entt/meta/meta_func.cpp

@@ -93,24 +93,24 @@ struct MetaFunc: ::testing::Test {
     void SetUp() override {
         using namespace entt::literals;
 
-        entt::meta<double>()
+        entt::meta_factory<double>{}
             .type("double"_hs)
             .func<&double_member>("member"_hs);
 
-        entt::meta<base>()
+        entt::meta_factory<base>{}
             .type("base"_hs)
             .func<&base::setter>("setter"_hs)
             .func<fake_member>("fake_member"_hs)
             .func<fake_const_member>("fake_const_member"_hs);
 
-        entt::meta<derived>()
+        entt::meta_factory<derived>{}
             .type("derived"_hs)
             .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);
 
-        entt::meta<function>()
+        entt::meta_factory<function>{}
             .type("func"_hs)
             .func<&entt::registry::emplace_or_replace<function>, entt::as_ref_t>("emplace"_hs)
             .traits(test::meta_traits::one | test::meta_traits::two | test::meta_traits::three)
@@ -175,7 +175,7 @@ ENTT_DEBUG_TEST_F(MetaFuncDeathTest, UserTraits) {
 
     using traits_type = entt::internal::meta_traits;
     constexpr auto value = traits_type{static_cast<std::underlying_type_t<traits_type>>(traits_type::_user_defined_traits) + 1u};
-    ASSERT_DEATH(entt::meta<function>().func<&function::g>("g"_hs).traits(value), "");
+    ASSERT_DEATH(entt::meta_factory<function>{}.func<&function::g>("g"_hs).traits(value), "");
 }
 
 TEST_F(MetaFunc, Custom) {
@@ -591,7 +591,7 @@ TEST_F(MetaFunc, Overloaded) {
 
     ASSERT_FALSE(type.func("f2"_hs).next());
 
-    entt::meta<function>()
+    entt::meta_factory<function>{}
         // this should not overwrite traits and custom data
         .func<entt::overload<int(int, int)>(&function::f)>("f2"_hs)
         // this should put traits and custom data on the new overload instead
@@ -615,7 +615,7 @@ TEST_F(MetaFunc, Overloaded) {
 TEST_F(MetaFunc, OverloadedOrder) {
     using namespace entt::literals;
 
-    entt::meta<function>()
+    entt::meta_factory<function>{}
         .func<entt::overload<int(int, int)>(&function::f)>("f2"_hs)
         .func<entt::overload<int(int) const>(&function::f)>("f2"_hs);
 
@@ -655,7 +655,7 @@ TEST_F(MetaFunc, ReRegistration) {
     ASSERT_TRUE(type.invoke("f1"_hs, instance, 0));
     ASSERT_FALSE(type.invoke("f1"_hs, instance, 0, 0));
 
-    entt::meta<function>()
+    entt::meta_factory<function>{}
         .func<entt::overload<int(int, int)>(&function::f)>("f"_hs)
         .func<entt::overload<int(int) const>(&function::f)>("f"_hs);
 
@@ -666,7 +666,7 @@ TEST_F(MetaFunc, ReRegistration) {
     ASSERT_TRUE(type.invoke("f"_hs, instance, 0));
     ASSERT_TRUE(type.invoke("f"_hs, instance, 0, 0));
 
-    entt::meta<function>()
+    entt::meta_factory<function>{}
         .func<entt::overload<int(int, int)>(&function::f)>("f"_hs)
         .traits(test::meta_traits::one)
         .custom<int>(3)

test/entt/meta/meta_handle.cpp

@@ -20,7 +20,7 @@ struct MetaHandle: ::testing::Test {
     void SetUp() override {
         using namespace entt::literals;
 
-        entt::meta<clazz>()
+        entt::meta_factory<clazz>{}
             .type("clazz"_hs)
             .func<&clazz::incr>("incr"_hs)
             .func<&clazz::decr>("decr"_hs);

test/entt/meta/meta_range.cpp

@@ -12,7 +12,9 @@ struct MetaRange: ::testing::Test {
     void SetUp() override {
         using namespace entt::literals;
 
-        entt::meta<int>().type("int"_hs).data<2>("answer"_hs);
+        entt::meta_factory<int>{}
+            .type("int"_hs)
+            .data<2>("answer"_hs);
     }
 
     void TearDown() override {
@@ -73,7 +75,7 @@ TEST_F(MetaRange, Iterator) {
     ASSERT_GT(end, begin);
     ASSERT_GE(end, range.end());
 
-    entt::meta<double>().type("double"_hs);
+    entt::meta_factory<double>{}.type("double"_hs);
     range = entt::resolve();
     begin = range.begin();
 

test/entt/meta/meta_type.cpp

@@ -105,37 +105,37 @@ struct MetaType: ::testing::Test {
     void SetUp() override {
         using namespace entt::literals;
 
-        entt::meta<double>()
+        entt::meta_factory<double>{}
             .type("double"_hs)
             .traits(test::meta_traits::one)
             .data<set<double>, get<double>>("var"_hs);
 
-        entt::meta<unsigned int>()
+        entt::meta_factory<unsigned int>{}
             .type("unsigned int"_hs)
             .traits(test::meta_traits::two)
             .data<0u>("min"_hs)
             .data<128u>("max"_hs);
 
-        entt::meta<base>()
+        entt::meta_factory<base>{}
             .type("base"_hs)
             .data<&base::value>("value"_hs);
 
-        entt::meta<derived>()
+        entt::meta_factory<derived>{}
             .type("derived"_hs)
             .traits(test::meta_traits::one | test::meta_traits::three)
             .base<base>();
 
-        entt::meta<abstract>()
+        entt::meta_factory<abstract>{}
             .type("abstract"_hs)
             .func<&abstract::func>("func"_hs)
             .func<&abstract::base_only>("base_only"_hs);
 
-        entt::meta<concrete>()
+        entt::meta_factory<concrete>{}
             .type("concrete"_hs)
             .base<base>()
             .base<abstract>();
 
-        entt::meta<overloaded_func>()
+        entt::meta_factory<overloaded_func>{}
             .type("overloaded_func"_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)
@@ -143,14 +143,14 @@ struct MetaType: ::testing::Test {
             .func<entt::overload<int(int) const>(&overloaded_func::f)>("f"_hs)
             .func<entt::overload<float(int, float)>(&overloaded_func::f)>("f"_hs);
 
-        entt::meta<property_type>()
+        entt::meta_factory<property_type>{}
             .type("property"_hs)
             .traits(test::meta_traits::two | test::meta_traits::three)
             .data<property_type::value>("value"_hs)
             .data<property_type::other>("other"_hs)
             .data<set<property_type>, get<property_type>>("var"_hs);
 
-        entt::meta<clazz>()
+        entt::meta_factory<clazz>{}
             .type("class"_hs)
             .custom<char>('c')
             .ctor<const base &, int>()
@@ -202,7 +202,7 @@ TEST_F(MetaType, UserTraits) {
 ENTT_DEBUG_TEST_F(MetaTypeDeathTest, UserTraits) {
     using traits_type = entt::internal::meta_traits;
     constexpr auto value = traits_type{static_cast<std::underlying_type_t<traits_type>>(traits_type::_user_defined_traits) + 1u};
-    ASSERT_DEATH(entt::meta<clazz>().traits(value), "");
+    ASSERT_DEATH(entt::meta_factory<clazz>{}.traits(value), "");
 }
 
 TEST_F(MetaType, Custom) {
@@ -602,7 +602,7 @@ TEST_F(MetaType, Reset) {
     // implicitly generated default constructor is not cleared
     ASSERT_TRUE(entt::resolve<clazz>().construct());
 
-    entt::meta<clazz>().type("class"_hs);
+    entt::meta_factory<clazz>{}.type("class"_hs);
 
     ASSERT_TRUE(entt::resolve("class"_hs));
 }
@@ -735,7 +735,7 @@ TEST_F(MetaType, ResetAndReRegistrationAfterReset) {
     ASSERT_FALSE(entt::resolve<clazz>().data("value"_hs));
     ASSERT_FALSE(entt::resolve<clazz>().func("member"_hs));
 
-    entt::meta<double>().type("double"_hs);
+    entt::meta_factory<double>{}.type("double"_hs);
     entt::meta_any any{3.};
 
     ASSERT_TRUE(any);
@@ -745,14 +745,14 @@ TEST_F(MetaType, ResetAndReRegistrationAfterReset) {
     ASSERT_FALSE(entt::resolve("derived"_hs));
     ASSERT_TRUE(entt::resolve("double"_hs));
 
-    entt::meta<base>()
+    entt::meta_factory<base>{}
         .traits(test::meta_traits::one)
         .custom<int>(3)
         // this should not overwrite traits and custom data
         .type("base"_hs);
 
     // this should not overwrite traits and custom data
-    [[maybe_unused]] auto factory = entt::meta<base>();
+    [[maybe_unused]] entt::meta_factory<base> factory{};
 
     ASSERT_EQ(entt::resolve<base>().traits<test::meta_traits>(), test::meta_traits::one);
     ASSERT_NE(static_cast<const int *>(entt::resolve("base"_hs).custom()), nullptr);
@@ -776,13 +776,13 @@ TEST_F(MetaType, ReRegistration) {
     ASSERT_EQ(count, 0);
     ASSERT_TRUE(entt::resolve("double"_hs));
 
-    entt::meta<double>()
+    entt::meta_factory<double>{}
         .type("real"_hs)
         .traits(test::meta_traits::one)
         .custom<int>(3);
 
     // this should not overwrite traits and custom data
-    entt::meta<double>().type("real"_hs);
+    entt::meta_factory<double>{}.type("real"_hs);
 
     ASSERT_FALSE(entt::resolve("double"_hs));
     ASSERT_TRUE(entt::resolve("real"_hs));
@@ -795,10 +795,10 @@ TEST_F(MetaType, ReRegistration) {
 TEST_F(MetaType, NameCollision) {
     using namespace entt::literals;
 
-    ASSERT_NO_THROW(entt::meta<clazz>().type("class"_hs));
+    ASSERT_NO_THROW(entt::meta_factory<clazz>{}.type("class"_hs));
     ASSERT_TRUE(entt::resolve("class"_hs));
 
-    ASSERT_NO_THROW(entt::meta<clazz>().type("quux"_hs));
+    ASSERT_NO_THROW(entt::meta_factory<clazz>{}.type("quux"_hs));
     ASSERT_FALSE(entt::resolve("class"_hs));
     ASSERT_TRUE(entt::resolve("quux"_hs));
 }
@@ -806,5 +806,5 @@ TEST_F(MetaType, NameCollision) {
 ENTT_DEBUG_TEST_F(MetaTypeDeathTest, NameCollision) {
     using namespace entt::literals;
 
-    ASSERT_DEATH(entt::meta<clazz>().type("abstract"_hs), "");
+    ASSERT_DEATH(entt::meta_factory<clazz>{}.type("abstract"_hs), "");
 }

test/example/entity_copy.cpp

@@ -29,7 +29,7 @@ meta_mixin<Type>::meta_mixin(const allocator_type &allocator)
     : Type{allocator} {
     using namespace entt::literals;
 
-    entt::meta<element_type>()
+    entt::meta_factory<element_type>{}
         // cross registry, same type
         .template func<entt::overload<entt::storage_for_t<element_type, entt::entity> &(const entt::id_type)>(&entt::basic_registry<entt::entity>::storage<element_type>), entt::as_ref_t>("storage"_hs)
         // cross registry, different types

test/lib/meta/plugin/plugin.cpp

@@ -15,12 +15,12 @@ test::boxed_int create_boxed_int(int value) {
 void set_up() {
     using namespace entt::literals;
 
-    entt::meta<test::boxed_int>()
+    entt::meta_factory<test::boxed_int>{}
         .type("boxed_int"_hs)
         .ctor<&create_boxed_int>()
         .data<&test::boxed_int::value>("value"_hs);
 
-    entt::meta<test::empty>()
+    entt::meta_factory<test::empty>{}
         .type("empty"_hs)
         .ctor<>();
 }

test/lib/meta/plugin_std/plugin.cpp

@@ -15,12 +15,12 @@ test::boxed_int create_boxed_int(int value) {
 void set_up() {
     using namespace entt::literals;
 
-    entt::meta<test::boxed_int>()
+    entt::meta_factory<test::boxed_int>{}
         .type("boxed_int"_hs)
         .ctor<&create_boxed_int>()
         .data<&test::boxed_int::value>("value"_hs);
 
-    entt::meta<test::empty>()
+    entt::meta_factory<test::empty>{}
         .type("empty"_hs)
         .ctor<>();
 }

test/lib/meta/shared/lib.cpp

@@ -18,16 +18,16 @@ ENTT_API void share(const entt::locator<entt::meta_ctx>::node_type &handle) {
 ENTT_API void set_up() {
     using namespace entt::literals;
 
-    entt::meta<test::boxed_int>()
+    entt::meta_factory<test::boxed_int>{}
         .type("boxed_int"_hs)
         .ctor<&create_boxed_int>()
         .data<&test::boxed_int::value>("value"_hs);
 
-    entt::meta<test::empty>()
+    entt::meta_factory<test::empty>{}
         .type("empty"_hs)
         .ctor<>();
 
-    static_cast<void>(entt::meta<double>());
+    static_cast<void>(entt::meta_factory<double>{});
 }
 
 ENTT_API void tear_down() {