meta: drop make_meta, unfortunately it doesn't fit well with the context aware design

src/entt/meta/meta.hpp

@@ -597,20 +597,6 @@ private:
     vtable_type *vtable;
 };
 
-/**
- * @brief Constructs a wrapper from a given type, passing it all arguments.
- * @tparam Type Type of object to use to initialize the wrapper.
- * @tparam Args Types of arguments to use to construct the new instance.
- * @param args Parameters to use to construct the instance.
- * @return A properly initialized wrapper for an object of the given type.
- */
-template<typename Type, typename... Args>
-meta_any make_meta(Args &&...args) {
-    return meta_any{std::in_place_type<Type>, std::forward<Args>(args)...};
-}
-
-// TODO context aware make_meta
-
 /**
  * @brief Forwards its argument and avoids copies for lvalue references.
  * @tparam Type Type of argument to use to construct the new instance.

test/entt/meta/meta_any.cpp

@@ -186,7 +186,7 @@ TEST_F(MetaAny, SBOAsRefConstruction) {
     ASSERT_NE(any, entt::meta_any{42});
     ASSERT_EQ(entt::meta_any{3}, any);
 
-    any = entt::make_meta<int &>(value);
+    any = entt::forward_as_meta(value);
 
     ASSERT_TRUE(any);
     ASSERT_EQ(any.type(), entt::resolve<int>());
@@ -221,7 +221,7 @@ TEST_F(MetaAny, SBOAsConstRefConstruction) {
     ASSERT_NE(any, entt::meta_any{42});
     ASSERT_EQ(entt::meta_any{3}, any);
 
-    any = entt::make_meta<const int &>(value);
+    any = entt::forward_as_meta(std::as_const(value));
 
     ASSERT_TRUE(any);
     ASSERT_EQ(any.type(), entt::resolve<int>());
@@ -453,7 +453,7 @@ TEST_F(MetaAny, NoSBOAsRefConstruction) {
     ASSERT_EQ(any, entt::meta_any{instance});
     ASSERT_NE(entt::meta_any{fat_t{}}, any);
 
-    any = entt::make_meta<fat_t &>(instance);
+    any = entt::forward_as_meta(instance);
 
     ASSERT_TRUE(any);
     ASSERT_EQ(any.type(), entt::resolve<fat_t>());
@@ -486,7 +486,7 @@ TEST_F(MetaAny, NoSBOAsConstRefConstruction) {
     ASSERT_EQ(any, entt::meta_any{instance});
     ASSERT_NE(entt::meta_any{fat_t{}}, any);
 
-    any = entt::make_meta<const fat_t &>(instance);
+    any = entt::forward_as_meta(std::as_const(instance));
 
     ASSERT_TRUE(any);
     ASSERT_EQ(any.type(), entt::resolve<fat_t>());
@@ -1348,21 +1348,6 @@ TEST_F(MetaAny, SetGet) {
     ASSERT_FALSE(any.get("non_existent"_hs));
 }
 
-TEST_F(MetaAny, MakeMeta) {
-    int value = 42;
-    auto any = entt::make_meta<int>(value);
-    auto ref = entt::make_meta<int &>(value);
-
-    ASSERT_TRUE(any);
-    ASSERT_TRUE(ref);
-
-    ASSERT_EQ(any.cast<const int &>(), 42);
-    ASSERT_EQ(ref.cast<const int &>(), 42);
-
-    ASSERT_NE(any.data(), &value);
-    ASSERT_EQ(ref.data(), &value);
-}
-
 TEST_F(MetaAny, ForwardAsMeta) {
     int value = 42;
     auto ref = entt::forward_as_meta(value);

test/entt/meta/meta_ctor.cpp

@@ -166,7 +166,7 @@ TEST_F(MetaCtor, FuncArithmeticConversion) {
 TEST_F(MetaCtor, FuncConstNonConstRefArgs) {
     int ivalue = 42;
     auto any = entt::resolve<clazz_t>().construct(entt::forward_as_meta(ivalue));
-    auto other = entt::resolve<clazz_t>().construct(entt::make_meta<const int &>(ivalue));
+    auto other = entt::resolve<clazz_t>().construct(entt::forward_as_meta(std::as_const(ivalue)));
 
     ASSERT_TRUE(any);
     ASSERT_TRUE(other);

test/entt/meta/meta_data.cpp

@@ -342,11 +342,11 @@ TEST_F(MetaData, SetByRef) {
     int value{42};
 
     ASSERT_EQ(any.cast<clazz_t>().i, 0);
-    ASSERT_TRUE(entt::resolve<clazz_t>().data("i"_hs).set(any, entt::make_meta<int &>(value)));
+    ASSERT_TRUE(entt::resolve<clazz_t>().data("i"_hs).set(any, entt::forward_as_meta(value)));
     ASSERT_EQ(any.cast<clazz_t>().i, 42);
 
     value = 3;
-    auto wrapper = entt::make_meta<int &>(value);
+    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);
@@ -359,11 +359,11 @@ TEST_F(MetaData, SetByConstRef) {
     int value{42};
 
     ASSERT_EQ(any.cast<clazz_t>().i, 0);
-    ASSERT_TRUE(entt::resolve<clazz_t>().data("i"_hs).set(any, entt::make_meta<const int &>(value)));
+    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, 42);
 
     value = 3;
-    auto wrapper = entt::make_meta<const int &>(value);
+    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);

test/entt/meta/meta_dtor.cpp

@@ -75,7 +75,7 @@ TEST_F(MetaDtor, AsRefConstruction) {
 
     clazz_t instance{};
     auto any = entt::forward_as_meta(instance);
-    auto cany = entt::make_meta<const clazz_t &>(instance);
+    auto cany = entt::forward_as_meta(std::as_const(instance));
     auto cref = cany.as_ref();
     auto ref = any.as_ref();
 

test/entt/meta/meta_func.cpp

@@ -449,7 +449,7 @@ TEST_F(MetaFunc, ArgsByConstRef) {
     entt::meta_any any{2};
     int value = 3;
 
-    ASSERT_TRUE(func.invoke(instance, entt::make_meta<const int &>(value)));
+    ASSERT_TRUE(func.invoke(instance, entt::forward_as_meta(std::as_const(value))));
     ASSERT_EQ(func_t::value, 9);
 
     ASSERT_TRUE(func.invoke(instance, std::as_const(any).as_ref()));