meta: args are always rebinded to the right context (with non-regression tests)

src/entt/meta/meta.hpp

@@ -835,7 +835,7 @@ struct meta_data {
      */
     template<typename Type>
     bool set(meta_handle instance, Type &&value) const {
-        return node->set && node->set(std::move(instance), std::forward<Type>(value));
+        return node->set && node->set(std::move(instance), meta_any{*ctx, std::forward<Type>(value)});
     }
 
     /**
@@ -975,7 +975,7 @@ struct meta_func {
      */
     template<typename... Args>
     meta_any invoke(meta_handle instance, Args &&...args) const {
-        meta_any arguments[sizeof...(Args) + 1u]{std::forward<Args>(args)...};
+        meta_any arguments[sizeof...(Args) + 1u]{{*ctx, std::forward<Args>(args)}...};
         return invoke(std::move(instance), arguments, sizeof...(Args));
     }
 
@@ -1364,7 +1364,7 @@ public:
      */
     template<typename... Args>
     [[nodiscard]] meta_any construct(Args &&...args) const {
-        meta_any arguments[sizeof...(Args) + 1u]{std::forward<Args>(args)...};
+        meta_any arguments[sizeof...(Args) + 1u]{{*ctx, std::forward<Args>(args)}...};
         return construct(arguments, sizeof...(Args));
     }
 
@@ -1431,7 +1431,7 @@ public:
      */
     template<typename... Args>
     meta_any invoke(const id_type id, meta_handle instance, Args &&...args) const {
-        meta_any arguments[sizeof...(Args) + 1u]{std::forward<Args>(args)...};
+        meta_any arguments[sizeof...(Args) + 1u]{{*ctx, std::forward<Args>(args)}...}; // TODO
         return invoke(id, std::move(instance), arguments, sizeof...(Args));
     }
 

test/entt/meta/meta_context.cpp

@@ -13,11 +13,11 @@ struct base {};
 struct clazz: base {
     clazz() = default;
 
-    clazz(int)
-        : clazz{} {}
+    clazz(int v)
+        : value{v} {}
 
-    clazz(char, int)
-        : clazz{} {}
+    clazz(char, int v)
+        : value{v} {}
 
     int func(int v) {
         return (value = v);
@@ -169,6 +169,17 @@ TEST_F(MetaContext, MetaType) {
 
     ASSERT_EQ(global.id(), "foo"_hs);
     ASSERT_EQ(local.id(), "bar"_hs);
+
+    clazz instance{};
+    const argument value{2};
+
+    ASSERT_NE(instance.value, value.get());
+    ASSERT_EQ(global.invoke("func"_hs, instance, value).cast<int>(), value.get());
+    ASSERT_EQ(instance.value, value.get());
+
+    ASSERT_NE(instance.value, value.get_mul());
+    ASSERT_EQ(local.invoke("func"_hs, instance, value).cast<int>(), value.get_mul());
+    ASSERT_NE(instance.value, value.get_mul());
 }
 
 TEST_F(MetaContext, MetaBase) {
@@ -208,12 +219,12 @@ TEST_F(MetaContext, MetaData) {
     clazz instance{};
     const argument value{2};
 
-    grw.set(instance, value);
-
+    ASSERT_NE(instance.value, value.get());
+    ASSERT_TRUE(grw.set(instance, value));
     ASSERT_EQ(instance.value, value.get());
 
-    lrw.set(entt::meta_handle{context, instance}, entt::meta_any{context, value});
-
+    ASSERT_NE(instance.value, value.get_mul());
+    ASSERT_TRUE(lrw.set(instance, value));
     ASSERT_EQ(instance.value, value.get_mul());
 }
 
@@ -243,7 +254,7 @@ TEST_F(MetaContext, MetaFunc) {
     ASSERT_EQ(instance.value, value.get());
 
     ASSERT_NE(instance.value, value.get_mul());
-    ASSERT_EQ(local.invoke(entt::meta_handle{context, instance}, entt::meta_any{context, value}).cast<int>(), value.get_mul());
+    ASSERT_EQ(local.invoke(instance, value).cast<int>(), value.get_mul());
     ASSERT_NE(instance.value, value.get_mul());
 }
 
@@ -251,14 +262,30 @@ TEST_F(MetaContext, MetaCtor) {
     const auto global = entt::resolve<clazz>();
     const auto local = entt::resolve<clazz>(context);
 
-    ASSERT_TRUE(global.construct());
-    ASSERT_TRUE(local.construct());
+    auto any = global.construct();
+    auto other = local.construct();
 
-    ASSERT_TRUE(global.construct(0));
-    ASSERT_FALSE(local.construct(0));
+    ASSERT_TRUE(any);
+    ASSERT_TRUE(other);
 
-    ASSERT_FALSE(global.construct('c', 0));
-    ASSERT_TRUE(local.construct('c', 0));
+    ASSERT_EQ(any.cast<const clazz &>().value, 0);
+    ASSERT_EQ(other.cast<const clazz &>().value, 0);
+
+    argument argument{2};
+
+    any = global.construct(argument);
+    other = local.construct(argument);
+
+    ASSERT_TRUE(any);
+    ASSERT_FALSE(other);
+    ASSERT_EQ(any.cast<const clazz &>().value, 2);
+
+    any = global.construct('c', argument);
+    other = local.construct('c', argument);
+
+    ASSERT_FALSE(any);
+    ASSERT_TRUE(other);
+    ASSERT_EQ(other.cast<const clazz &>().value, 4);
 }
 
 TEST_F(MetaContext, MetaConv) {