meta: avoid storing meta type nodes by reference in the meta factory

src/entt/meta/factory.hpp

@@ -103,6 +103,10 @@ private:
  */
 template<typename Type>
 class meta_factory<Type> {
+    decltype(auto) owner() {
+        return internal::meta_context::from(locator<meta_ctx>::value_or()).value[type_id<Type>().hash()];
+    }
+
     template<typename Setter, auto Getter, typename Policy, std::size_t... Index>
     auto data(const id_type id, std::index_sequence<Index...>) noexcept {
         using data_type = std::invoke_result_t<decltype(Getter), Type &>;
@@ -118,15 +122,17 @@ class meta_factory<Type> {
             +[](meta_handle instance, meta_any value) -> bool { return (meta_setter<Type, value_list_element_v<Index, Setter>>(*instance.operator->(), value.as_ref()) || ...); },
             &meta_getter<Type, Getter, Policy>};
 
-        internal::meta_details_setup(*owner);
-        auto it = owner->details->data.insert_or_assign(id, std::move(node)).first;
+        auto &&elem = owner();
+        internal::meta_details_setup(elem);
+        auto it = elem.details->data.insert_or_assign(id, std::move(node)).first;
         return meta_factory<Type, internal::meta_data_node>{it->second};
     }
 
 public:
     /*! @brief Default constructor. */
-    meta_factory() noexcept
-        : owner{&internal::meta_context::from(locator<meta_ctx>::value_or()).value.try_emplace(type_id<Type>().hash(), internal::resolve<Type>()).first->second} {}
+    meta_factory() noexcept {
+        internal::meta_context::from(locator<meta_ctx>::value_or()).value.try_emplace(type_id<Type>().hash(), internal::resolve<Type>());
+    }
 
     /**
      * @brief Assigns a custom unique identifier to a meta type.
@@ -134,9 +140,10 @@ public:
      * @return An extended meta factory for the given type.
      */
     auto type(const id_type id) noexcept {
-        ENTT_ASSERT(owner->id == id || !resolve(id), "Duplicate identifier");
-        owner->id = id;
-        return meta_factory<Type, internal::meta_type_node>{*owner};
+        auto &&elem = owner();
+        ENTT_ASSERT(elem.id == id || !resolve(id), "Duplicate identifier");
+        elem.id = id;
+        return meta_factory<Type, internal::meta_type_node>{elem};
     }
 
     /**
@@ -150,9 +157,11 @@ public:
     template<typename Base>
     auto base() noexcept {
         static_assert(!std::is_same_v<Type, Base> && std::is_base_of_v<Base, Type>, "Invalid base type");
-        internal::meta_details_setup(*owner);
 
-        owner->details->base[type_id<Base>().hash()] = internal::meta_base_node{
+        auto &&elem = owner();
+        internal::meta_details_setup(elem);
+
+        elem.details->base[type_id<Base>().hash()] = internal::meta_base_node{
             &internal::resolve<Base>,
             +[](meta_any other) noexcept -> meta_any {
                 if(auto *ptr = other.data(); ptr) {
@@ -180,9 +189,11 @@ public:
     template<auto Candidate>
     auto conv() noexcept {
         using conv_type = std::remove_cv_t<std::remove_reference_t<std::invoke_result_t<decltype(Candidate), Type &>>>;
-        internal::meta_details_setup(*owner);
 
-        owner->details->conv[type_id<conv_type>().hash()] = internal::meta_conv_node{
+        auto &&elem = owner();
+        internal::meta_details_setup(elem);
+
+        elem.details->conv[type_id<conv_type>().hash()] = internal::meta_conv_node{
             +[](const meta_any &instance) -> meta_any {
                 return forward_as_meta(std::invoke(Candidate, *static_cast<const Type *>(instance.data())));
             }};
@@ -202,9 +213,11 @@ public:
     template<typename To>
     auto conv() noexcept {
         using conv_type = std::remove_cv_t<std::remove_reference_t<To>>;
-        internal::meta_details_setup(*owner);
 
-        owner->details->conv[type_id<conv_type>().hash()] = internal::meta_conv_node{
+        auto &&elem = owner();
+        internal::meta_details_setup(elem);
+
+        elem.details->conv[type_id<conv_type>().hash()] = internal::meta_conv_node{
             +[](const meta_any &instance) -> meta_any {
                 return forward_as_meta(static_cast<To>(*static_cast<const Type *>(instance.data())));
             }};
@@ -230,9 +243,11 @@ public:
         using descriptor = meta_function_helper_t<Type, decltype(Candidate)>;
         static_assert(Policy::template value<typename descriptor::return_type>, "Invalid return type for the given policy");
         static_assert(std::is_same_v<std::remove_cv_t<std::remove_reference_t<typename descriptor::return_type>>, Type>, "The function doesn't return an object of the required type");
-        internal::meta_details_setup(*owner);
 
-        owner->details->ctor[type_id<typename descriptor::args_type>().hash()] = internal::meta_ctor_node{
+        auto &&elem = owner();
+        internal::meta_details_setup(elem);
+
+        elem.details->ctor[type_id<typename descriptor::args_type>().hash()] = internal::meta_ctor_node{
             descriptor::args_type::size,
             &meta_arg<typename descriptor::args_type>,
             &meta_construct<Type, Candidate, Policy>};
@@ -253,9 +268,11 @@ public:
     template<typename... Args>
     auto ctor() noexcept {
         using descriptor = meta_function_helper_t<Type, Type (*)(Args...)>;
-        internal::meta_details_setup(*owner);
 
-        owner->details->ctor[type_id<typename descriptor::args_type>().hash()] = internal::meta_ctor_node{
+        auto &&elem = owner();
+        internal::meta_details_setup(elem);
+
+        elem.details->ctor[type_id<typename descriptor::args_type>().hash()] = internal::meta_ctor_node{
             descriptor::args_type::size,
             &meta_arg<typename descriptor::args_type>,
             &meta_construct<Type, Args...>};
@@ -284,7 +301,7 @@ public:
     template<auto Func>
     auto dtor() noexcept {
         static_assert(std::is_invocable_v<decltype(Func), Type &>, "The function doesn't accept an object of the type provided");
-        owner->dtor.dtor = +[](void *instance) { std::invoke(Func, *static_cast<Type *>(instance)); };
+        owner().dtor.dtor = +[](void *instance) { std::invoke(Func, *static_cast<Type *>(instance)); };
         return *this;
     }
 
@@ -303,7 +320,8 @@ public:
      */
     template<auto Data, typename Policy = as_is_t>
     auto data(const id_type id) noexcept {
-        internal::meta_details_setup(*owner);
+        auto &&elem = owner();
+        internal::meta_details_setup(elem);
 
         if constexpr(std::is_member_object_pointer_v<decltype(Data)>) {
             using data_type = std::remove_reference_t<std::invoke_result_t<decltype(Data), Type &>>;
@@ -317,7 +335,7 @@ public:
                 &meta_setter<Type, Data>,
                 &meta_getter<Type, Data, Policy>};
 
-            auto it = owner->details->data.insert_or_assign(id, std::move(node)).first;
+            auto it = elem.details->data.insert_or_assign(id, std::move(node)).first;
             return meta_factory<Type, internal::meta_data_node>{it->second};
         } else {
             using data_type = std::remove_reference_t<std::remove_pointer_t<decltype(Data)>>;
@@ -330,7 +348,7 @@ public:
                 &meta_setter<Type, Data>,
                 &meta_getter<Type, Data, Policy>};
 
-            auto it = owner->details->data.insert_or_assign(id, std::move(node)).first;
+            auto it = elem.details->data.insert_or_assign(id, std::move(node)).first;
             return meta_factory<Type, internal::meta_data_node>{it->second};
         }
     }
@@ -359,7 +377,9 @@ public:
     auto data(const id_type id) noexcept {
         using data_type = std::invoke_result_t<decltype(Getter), Type &>;
         static_assert(Policy::template value<data_type>, "Invalid return type for the given policy");
-        internal::meta_details_setup(*owner);
+
+        auto &&elem = owner();
+        internal::meta_details_setup(elem);
 
         if constexpr(std::is_same_v<decltype(Setter), std::nullptr_t>) {
             internal::meta_data_node node{
@@ -371,7 +391,7 @@ public:
                 &meta_setter<Type, Setter>,
                 &meta_getter<Type, Getter, Policy>};
 
-            auto it = owner->details->data.insert_or_assign(id, std::move(node)).first;
+            auto it = elem.details->data.insert_or_assign(id, std::move(node)).first;
             return meta_factory<Type, internal::meta_data_node>{it->second};
         } else {
             using args_type = typename meta_function_helper_t<Type, decltype(Setter)>::args_type;
@@ -385,7 +405,7 @@ public:
                 &meta_setter<Type, Setter>,
                 &meta_getter<Type, Getter, Policy>};
 
-            auto it = owner->details->data.insert_or_assign(id, std::move(node)).first;
+            auto it = elem.details->data.insert_or_assign(id, std::move(node)).first;
             return meta_factory<Type, internal::meta_data_node>{it->second};
         }
     }
@@ -429,7 +449,9 @@ public:
     auto func(const id_type id) noexcept {
         using descriptor = meta_function_helper_t<Type, decltype(Candidate)>;
         static_assert(Policy::template value<typename descriptor::return_type>, "Invalid return type for the given policy");
-        internal::meta_details_setup(*owner);
+
+        auto &&elem = owner();
+        internal::meta_details_setup(elem);
 
         internal::meta_func_node node{
             (descriptor::is_const ? internal::meta_traits::is_const : internal::meta_traits::is_none) | (descriptor::is_static ? internal::meta_traits::is_static : internal::meta_traits::is_none),
@@ -438,7 +460,7 @@ public:
             &meta_arg<typename descriptor::args_type>,
             &meta_invoke<Type, Candidate, Policy>};
 
-        if(auto it = owner->details->func.find(id); it != owner->details->func.end()) {
+        if(auto it = elem.details->func.find(id); it != elem.details->func.end()) {
             for(auto *curr = &it->second; curr; curr = curr->next.get()) {
                 if(curr->invoke == node.invoke) {
                     node.next = std::move(curr->next);
@@ -449,15 +471,12 @@ public:
             }
 
             // locally overloaded function
-            node.next = std::make_shared<internal::meta_func_node>(std::move(owner->details->func[id]));
+            node.next = std::make_shared<internal::meta_func_node>(std::move(elem.details->func[id]));
         }
 
-        owner->details->func.insert_or_assign(id, std::move(node));
-        return meta_factory<Type, internal::meta_func_node>{owner->details->func[id]};
+        elem.details->func.insert_or_assign(id, std::move(node));
+        return meta_factory<Type, internal::meta_func_node>{elem.details->func[id]};
     }
-
-private:
-    internal::meta_type_node *owner;
 };
 
 /**