meta: context aware resolve functions (with internal temporary trampoline)

src/entt/meta/factory.hpp

@@ -103,7 +103,7 @@ class meta_factory {
                 /* this is never static */
                 (std::is_member_object_pointer_v<decltype(value_list_element_v<Index, Setter>)> && ... && std::is_const_v<std::remove_reference_t<data_type>>) ? internal::meta_traits::is_const : internal::meta_traits::is_none,
                 Setter::size,
-                &internal::resolve<std::remove_cv_t<std::remove_reference_t<data_type>>>,
+                &internal::resolve_TODO<std::remove_cv_t<std::remove_reference_t<data_type>>>,
                 &meta_arg<type_list<type_list_element_t<type_list_element_t<Index, args_type>::size != 1u, type_list_element_t<Index, args_type>>...>>,
                 +[](meta_handle instance, meta_any value) { return (meta_setter<Type, value_list_element_v<Index, Setter>>(*instance.operator->(), value.as_ref()) || ...); },
                 &meta_getter<Type, Getter, Policy>});
@@ -154,7 +154,7 @@ public:
             *info,
             type_id<Base>().hash(),
             internal::meta_base_node{
-                &internal::resolve<Base>,
+                &internal::resolve_TODO<Base>,
                 +[](const void *instance) noexcept {
                     return static_cast<const void *>(static_cast<const Base *>(static_cast<const Type *>(instance)));
                 }});
@@ -329,7 +329,7 @@ public:
                     /* this is never static */
                     std::is_const_v<data_type> ? internal::meta_traits::is_const : internal::meta_traits::is_none,
                     1u,
-                    &internal::resolve<std::remove_const_t<data_type>>,
+                    &internal::resolve_TODO<std::remove_const_t<data_type>>,
                     &meta_arg<type_list<std::remove_const_t<data_type>>>,
                     &meta_setter<Type, Data>,
                     &meta_getter<Type, Data, Policy>});
@@ -344,7 +344,7 @@ public:
                 internal::meta_data_node{
                     ((std::is_same_v<Type, std::remove_const_t<data_type>> || std::is_const_v<data_type>) ? internal::meta_traits::is_const : internal::meta_traits::is_none) | internal::meta_traits::is_static,
                     1u,
-                    &internal::resolve<std::remove_const_t<data_type>>,
+                    &internal::resolve_TODO<std::remove_const_t<data_type>>,
                     &meta_arg<type_list<std::remove_const_t<data_type>>>,
                     &meta_setter<Type, Data>,
                     &meta_getter<Type, Data, Policy>});
@@ -388,7 +388,7 @@ public:
                     /* this is never static */
                     internal::meta_traits::is_const,
                     0u,
-                    &internal::resolve<std::remove_cv_t<std::remove_reference_t<data_type>>>,
+                    &internal::resolve_TODO<std::remove_cv_t<std::remove_reference_t<data_type>>>,
                     &meta_arg<type_list<>>,
                     &meta_setter<Type, Setter>,
                     &meta_getter<Type, Getter, Policy>});
@@ -404,7 +404,7 @@ public:
                     /* this is never static nor const */
                     internal::meta_traits::is_none,
                     1u,
-                    &internal::resolve<std::remove_cv_t<std::remove_reference_t<data_type>>>,
+                    &internal::resolve_TODO<std::remove_cv_t<std::remove_reference_t<data_type>>>,
                     &meta_arg<type_list<type_list_element_t<args_type::size != 1u, args_type>>>,
                     &meta_setter<Type, Setter>,
                     &meta_getter<Type, Getter, Policy>});
@@ -462,7 +462,7 @@ public:
             internal::meta_func_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),
                 descriptor::args_type::size,
-                &internal::resolve<std::conditional_t<std::is_same_v<Policy, as_void_t>, void, std::remove_cv_t<std::remove_reference_t<typename descriptor::return_type>>>>,
+                &internal::resolve_TODO<std::conditional_t<std::is_same_v<Policy, as_void_t>, void, std::remove_cv_t<std::remove_reference_t<typename descriptor::return_type>>>>,
                 &meta_arg<typename descriptor::args_type>,
                 &meta_invoke<Type, Candidate, Policy>});
 
@@ -489,13 +489,13 @@ public:
                 *bucket,
                 id,
                 internal::meta_prop_node{
-                    &internal::resolve<void>});
+                    &internal::resolve_TODO<void>});
         } else {
             internal::meta_extend(
                 *bucket,
                 id,
                 internal::meta_prop_node{
-                    &internal::resolve<std::decay_t<Value>>...,
+                    &internal::resolve_TODO<std::decay_t<Value>>...,
                     std::make_shared<std::decay_t<Value>>(std::forward<Value>(value))...});
         }
 
@@ -521,7 +521,7 @@ private:
 template<typename Type>
 [[nodiscard]] auto meta() noexcept {
     // make sure the type exists in the context before returning a factory
-    internal::meta_context::from(locator<meta_ctx>::value_or()).value.try_emplace(type_id<Type>().hash(), internal::resolve<Type>());
+    internal::meta_context::from(locator<meta_ctx>::value_or()).value.try_emplace(type_id<Type>().hash(), internal::resolve_TODO<Type>());
     return meta_factory<Type>{};
 }
 

src/entt/meta/meta.hpp

@@ -45,7 +45,7 @@ public:
      */
     template<typename Type>
     meta_sequence_container(std::in_place_type_t<Type>, any instance) noexcept
-        : value_type_node{&internal::resolve<typename Type::value_type>},
+        : value_type_node{&internal::resolve_TODO<typename Type::value_type>},
           size_fn{&meta_sequence_container_traits<Type>::size},
           resize_fn{&meta_sequence_container_traits<Type>::resize},
           iter_fn{&meta_sequence_container_traits<Type>::iter},
@@ -93,9 +93,9 @@ public:
     template<typename Type>
     meta_associative_container(std::in_place_type_t<Type>, any instance) noexcept
         : key_only_container{meta_associative_container_traits<Type>::key_only},
-          key_type_node{&internal::resolve<typename Type::key_type>},
+          key_type_node{&internal::resolve_TODO<typename Type::key_type>},
           mapped_type_node{},
-          value_type_node{&internal::resolve<typename Type::value_type>},
+          value_type_node{&internal::resolve_TODO<typename Type::value_type>},
           size_fn{&meta_associative_container_traits<Type>::size},
           clear_fn{&meta_associative_container_traits<Type>::clear},
           iter_fn{&meta_associative_container_traits<Type>::iter},
@@ -103,7 +103,7 @@ public:
           find_fn{&meta_associative_container_traits<Type>::find},
           storage{std::move(instance)} {
         if constexpr(!meta_associative_container_traits<Type>::key_only) {
-            mapped_type_node = &internal::resolve<typename Type::mapped_type>;
+            mapped_type_node = &internal::resolve_TODO<typename Type::mapped_type>;
         }
     }
 
@@ -207,7 +207,7 @@ public:
     template<typename Type, typename... Args>
     explicit meta_any(std::in_place_type_t<Type>, Args &&...args)
         : storage{std::in_place_type<Type>, std::forward<Args>(args)...},
-          node{internal::resolve<std::remove_cv_t<std::remove_reference_t<Type>>>()},
+          node{internal::resolve_TODO<std::remove_cv_t<std::remove_reference_t<Type>>>()},
           vtable{&basic_vtable<std::remove_cv_t<std::remove_reference_t<Type>>>} {}
 
     /**
@@ -339,7 +339,7 @@ public:
      */
     template<typename Type>
     [[nodiscard]] const Type *try_cast() const {
-        return static_cast<const Type *>(internal::try_cast(node, internal::resolve<std::remove_cv_t<Type>>(), data()));
+        return static_cast<const Type *>(internal::try_cast(node, internal::resolve_TODO<std::remove_cv_t<Type>>(), data()));
     }
 
     /*! @copydoc try_cast */
@@ -348,7 +348,7 @@ public:
         if constexpr(std::is_const_v<Type>) {
             return std::as_const(*this).try_cast<std::remove_const_t<Type>>();
         } else {
-            return static_cast<Type *>(const_cast<void *>(internal::try_cast(node, internal::resolve<Type>(), data())));
+            return static_cast<Type *>(const_cast<void *>(internal::try_cast(node, internal::resolve_TODO<Type>(), data())));
         }
     }
 
@@ -415,7 +415,7 @@ public:
         if constexpr(std::is_reference_v<Type> && !std::is_const_v<std::remove_reference_t<Type>>) {
             return {};
         } else {
-            return allow_cast(internal::resolve<std::remove_cv_t<std::remove_reference_t<Type>>>());
+            return allow_cast(internal::resolve_TODO<std::remove_cv_t<std::remove_reference_t<Type>>>());
         }
     }
 
@@ -427,9 +427,9 @@ public:
     template<typename Type>
     bool allow_cast() {
         if constexpr(std::is_reference_v<Type> && !std::is_const_v<std::remove_reference_t<Type>>) {
-            return allow_cast(internal::resolve<std::remove_cv_t<std::remove_reference_t<Type>>>()) && (storage.data() != nullptr);
+            return allow_cast(internal::resolve_TODO<std::remove_cv_t<std::remove_reference_t<Type>>>()) && (storage.data() != nullptr);
         } else {
-            return allow_cast(internal::resolve<std::remove_cv_t<std::remove_reference_t<Type>>>());
+            return allow_cast(internal::resolve_TODO<std::remove_cv_t<std::remove_reference_t<Type>>>());
         }
     }
 
@@ -438,7 +438,7 @@ public:
     void emplace(Args &&...args) {
         release();
         storage.emplace<Type>(std::forward<Args>(args)...);
-        node = internal::resolve<std::remove_cv_t<std::remove_reference_t<Type>>>();
+        node = internal::resolve_TODO<std::remove_cv_t<std::remove_reference_t<Type>>>();
         vtable = &basic_vtable<std::remove_cv_t<std::remove_reference_t<Type>>>;
     }
 

src/entt/meta/node.hpp

@@ -13,7 +13,6 @@
 #include "../core/type_info.hpp"
 #include "../core/type_traits.hpp"
 #include "../core/utility.hpp"
-#include "../locator/locator.hpp"
 #include "context.hpp"
 #include "type_traits.hpp"
 
@@ -138,7 +137,7 @@ template<typename... Args>
 [[nodiscard]] auto meta_arg_node(type_list<Args...>, [[maybe_unused]] const std::size_t index) noexcept {
     std::size_t pos{};
     meta_type_node (*value)() noexcept = nullptr;
-    ((value = (pos++ == index ? &resolve<std::remove_cv_t<std::remove_reference_t<Args>>> : value)), ...);
+    ((value = (pos++ == index ? &resolve_TODO<std::remove_cv_t<std::remove_reference_t<Args>>> : value)), ...);
     ENTT_ASSERT(value != nullptr, "Out of bounds");
     return value();
 }
@@ -159,17 +158,21 @@ template<typename... Args>
     return nullptr;
 }
 
-[[nodiscard]] inline meta_type_node *try_resolve(const type_info &info) noexcept {
-    auto &&context = meta_context::from(locator<meta_ctx>::value_or());
+[[nodiscard]] inline const meta_type_node *try_resolve(const meta_context &context, const type_info &info) noexcept {
     const auto it = context.value.find(info.hash());
     return it != context.value.end() ? &it->second : nullptr;
 }
 
 template<typename Type>
-[[nodiscard]] meta_type_node resolve() noexcept {
+[[nodiscard]] meta_type_node resolve_TODO() noexcept {
+    return resolve<Type>(meta_context::from(locator<meta_ctx>::value_or()));
+}
+
+template<typename Type>
+[[nodiscard]] meta_type_node resolve(const meta_context &context) noexcept {
     static_assert(std::is_same_v<Type, std::remove_const_t<std::remove_reference_t<Type>>>, "Invalid type");
 
-    if(auto *elem = try_resolve(type_id<Type>()); elem) {
+    if(auto *elem = try_resolve(context, type_id<Type>()); elem) {
         return *elem;
     }
 
@@ -186,7 +189,7 @@ template<typename Type>
             | (is_complete_v<meta_sequence_container_traits<Type>> ? meta_traits::is_meta_sequence_container : meta_traits::is_none)
             | (is_complete_v<meta_associative_container_traits<Type>> ? meta_traits::is_meta_associative_container : meta_traits::is_none),
         size_of_v<Type>,
-        &resolve<std::remove_cv_t<std::remove_pointer_t<Type>>>};
+        &resolve_TODO<std::remove_cv_t<std::remove_pointer_t<Type>>>};
 
     if constexpr(std::is_default_constructible_v<Type>) {
         node.default_constructor = +[]() { return meta_any{std::in_place_type<Type>}; };
@@ -215,7 +218,7 @@ template<typename Type>
     if constexpr(is_complete_v<meta_template_traits<Type>>) {
         node.templ = meta_template_node{
             meta_template_traits<Type>::args_type::size,
-            &resolve<typename meta_template_traits<Type>::class_type>,
+            &resolve_TODO<typename meta_template_traits<Type>::class_type>,
             +[](const std::size_t index) noexcept { return meta_arg_node(typename meta_template_traits<Type>::args_type{}, index); }};
     }
 

src/entt/meta/resolve.hpp

@@ -11,6 +11,18 @@
 
 namespace entt {
 
+/**
+ * @brief Returns the meta type associated with a given type.
+ * @tparam Type Type to use to search for a meta type.
+ * @param context The context from which to search for meta types.
+ * @return The meta type associated with the given type, if any.
+ */
+template<typename Type>
+[[nodiscard]] meta_type resolve(const meta_ctx &context) noexcept {
+    auto &&ctx = internal::meta_context::from(context);
+    return internal::resolve<std::remove_cv_t<std::remove_reference_t<Type>>>(ctx);
+}
+
 /**
  * @brief Returns the meta type associated with a given type.
  * @tparam Type Type to use to search for a meta type.
@@ -18,7 +30,17 @@ namespace entt {
  */
 template<typename Type>
 [[nodiscard]] meta_type resolve() noexcept {
-    return internal::resolve<std::remove_cv_t<std::remove_reference_t<Type>>>();
+    return resolve<Type>(locator<meta_ctx>::value_or());
+}
+
+/**
+ * @brief Returns a range to use to visit all meta types.
+ * @param context The context from which to search for meta types.
+ * @return An iterable range to use to visit all meta types.
+ */
+[[nodiscard]] inline meta_range<meta_type, typename decltype(internal::meta_context::value)::const_iterator> resolve(const meta_ctx &context) noexcept {
+    auto &&ctx = internal::meta_context::from(context);
+    return {ctx.value.cbegin(), ctx.value.cend()};
 }
 
 /**
@@ -26,17 +48,17 @@ template<typename Type>
  * @return An iterable range to use to visit all meta types.
  */
 [[nodiscard]] inline meta_range<meta_type, typename decltype(internal::meta_context::value)::const_iterator> resolve() noexcept {
-    auto &&context = internal::meta_context::from(locator<meta_ctx>::value_or());
-    return {context.value.cbegin(), context.value.cend()};
+    return resolve(locator<meta_ctx>::value_or());
 }
 
 /**
  * @brief Returns the meta type associated with a given identifier, if any.
+ * @param context The context from which to search for meta types.
  * @param id Unique identifier.
  * @return The meta type associated with the given identifier, if any.
  */
-[[nodiscard]] inline meta_type resolve(const id_type id) noexcept {
-    for(auto &&curr: resolve()) {
+[[nodiscard]] inline meta_type resolve(const meta_ctx &context, const id_type id) noexcept {
+    for(auto &&curr: resolve(context)) {
         if(curr.second.id() == id) {
             return curr.second;
         }
@@ -45,16 +67,36 @@ template<typename Type>
     return {};
 }
 
+/**
+ * @brief Returns the meta type associated with a given identifier, if any.
+ * @param id Unique identifier.
+ * @return The meta type associated with the given identifier, if any.
+ */
+[[nodiscard]] inline meta_type resolve(const id_type id) noexcept {
+    return resolve(locator<meta_ctx>::value_or(), id);
+}
+
 /**
  * @brief Returns the meta type associated with a given type info object.
+ * @param context The context from which to search for meta types.
  * @param info The type info object of the requested type.
  * @return The meta type associated with the given type info object, if any.
  */
-[[nodiscard]] inline meta_type resolve(const type_info &info) noexcept {
-    const auto *elem = internal::try_resolve(info);
+[[nodiscard]] inline meta_type resolve(const meta_ctx &context, const type_info &info) noexcept {
+    auto &&ctx = internal::meta_context::from(context);
+    const auto *elem = internal::try_resolve(ctx, info);
     return elem ? *elem : meta_type{};
 }
 
+/**
+ * @brief Returns the meta type associated with a given type info object.
+ * @param info The type info object of the requested type.
+ * @return The meta type associated with the given type info object, if any.
+ */
+[[nodiscard]] inline meta_type resolve(const type_info &info) noexcept {
+    return resolve(locator<meta_ctx>::value_or(), info);
+}
+
 } // namespace entt
 
 #endif

test/entt/meta/meta_base.cpp

@@ -181,7 +181,7 @@ TEST_F(MetaBase, TransferWithMutatingThis) {
 TEST_F(MetaBase, ReRegistration) {
     SetUp();
 
-    auto &&node = entt::internal::resolve<derived_t>();
+    auto &&node = entt::internal::resolve_TODO<derived_t>();
 
     ASSERT_TRUE(node.details);
     ASSERT_FALSE(node.details->base.empty());

test/entt/meta/meta_conv.cpp

@@ -62,7 +62,7 @@ TEST_F(MetaConv, Functionalities) {
 TEST_F(MetaConv, ReRegistration) {
     SetUp();
 
-    auto &&node = entt::internal::resolve<clazz_t>();
+    auto &&node = entt::internal::resolve_TODO<clazz_t>();
 
     ASSERT_TRUE(node.details);
     ASSERT_FALSE(node.details->conv.empty());

test/entt/meta/meta_ctor.cpp

@@ -205,7 +205,7 @@ TEST_F(MetaCtor, NonDefaultConstructibleType) {
 TEST_F(MetaCtor, ReRegistration) {
     SetUp();
 
-    auto &&node = entt::internal::resolve<double>();
+    auto &&node = entt::internal::resolve_TODO<double>();
 
     ASSERT_TRUE(node.details);
     ASSERT_FALSE(node.details->ctor.empty());

test/entt/meta/meta_data.cpp

@@ -645,7 +645,7 @@ TEST_F(MetaData, ReRegistration) {
 
     SetUp();
 
-    auto &&node = entt::internal::resolve<base_t>();
+    auto &&node = entt::internal::resolve_TODO<base_t>();
     auto type = entt::resolve<base_t>();
 
     ASSERT_TRUE(node.details);

test/entt/meta/meta_dtor.cpp

@@ -101,7 +101,7 @@ TEST_F(MetaDtor, AsRefConstruction) {
 TEST_F(MetaDtor, ReRegistration) {
     SetUp();
 
-    auto &&node = entt::internal::resolve<clazz_t>();
+    auto &&node = entt::internal::resolve_TODO<clazz_t>();
 
     ASSERT_NE(node.dtor.dtor, nullptr);
 

test/entt/meta/meta_prop.cpp

@@ -86,7 +86,7 @@ TEST_F(MetaProp, ReRegistration) {
 
     SetUp();
 
-    auto &&node = entt::internal::resolve<base_1_t>();
+    auto &&node = entt::internal::resolve_TODO<base_1_t>();
     auto type = entt::resolve<base_1_t>();
 
     ASSERT_TRUE(node.details);