meta: cleanup/prepare for meta_base first citizen type

src/entt/meta/factory.hpp

@@ -37,13 +37,13 @@ class basic_meta_factory {
     }
 
     [[nodiscard]] auto *find_member_or_assert() {
-        auto *member = find_member<&meta_data_node::id>(fetch_node().details->data, bucket);
+        auto *member = find_member(fetch_node().details->data, bucket);
         ENTT_ASSERT(member != nullptr, "Cannot find member");
         return member;
     }
 
     [[nodiscard]] auto *find_overload_or_assert() {
-        auto *overload = find_overload(find_member<&meta_func_node::id>(fetch_node().details->func, bucket), invoke);
+        auto *overload = find_overload(find_member(fetch_node().details->func, bucket), invoke);
         ENTT_ASSERT(overload != nullptr, "Cannot find overload");
         return overload;
     }
@@ -69,14 +69,14 @@ protected:
         reset_bucket(parent);
 
         if constexpr(std::is_same_v<Type, meta_base_node>) {
-            auto *member = find_member<&meta_base_node::type>(elem.details->base, node.type);
+            auto *member = find_member(elem.details->base, node.id);
             member ? (*member = node) : elem.details->base.emplace_back(node);
         } else if constexpr(std::is_same_v<Type, meta_conv_node>) {
-            auto *member = find_member<&meta_conv_node::type>(elem.details->conv, node.type);
+            auto *member = find_member(elem.details->conv, node.id);
             member ? (*member = node) : elem.details->conv.emplace_back(node);
         } else {
             static_assert(std::is_same_v<Type, meta_ctor_node>, "Unexpected type");
-            auto *member = find_member<&meta_ctor_node::id>(elem.details->ctor, node.id);
+            auto *member = find_member(elem.details->ctor, node.id);
             member ? (*member = node) : elem.details->ctor.emplace_back(node);
         }
     }
@@ -86,7 +86,7 @@ protected:
 
         reset_bucket(node.id);
 
-        if(auto *member = find_member<&meta_data_node::id>(elem.details->data, node.id); member == nullptr) {
+        if(auto *member = find_member(elem.details->data, node.id); member == nullptr) {
             elem.details->data.emplace_back(std::move(node));
         } else if(member->set != node.set || member->get != node.get) {
             *member = std::move(node);
@@ -98,7 +98,7 @@ protected:
 
         reset_bucket(node.id, node.invoke);
 
-        if(auto *member = find_member<&meta_func_node::id>(elem.details->func, node.id); member == nullptr) {
+        if(auto *member = find_member(elem.details->func, node.id); member == nullptr) {
             elem.details->func.emplace_back(std::move(node));
         } else if(auto *overload = find_overload(member, node.invoke); overload == nullptr) {
             while(member->next != nullptr) { member = member->next.get(); }

src/entt/meta/meta.hpp

@@ -482,12 +482,12 @@ public:
                 }
 
                 if(const auto &from = fetch_node(); from.details != nullptr) {
-                    if(const auto *elem = internal::find_member<&internal::meta_conv_node::type>(from.details->conv, entt::type_hash<std::remove_cvref_t<Type>>::value()); elem != nullptr) {
+                    if(const auto *elem = internal::find_member(from.details->conv, entt::type_hash<std::remove_cvref_t<Type>>::value()); elem != nullptr) {
                         return elem->conv(*ctx, storage.data());
                     }
 
                     for(auto &&curr: from.details->base) {
-                        if(auto other = curr.resolve(internal::meta_context::from(*ctx)).from_void(*ctx, nullptr, curr.cast(storage.data())); curr.type == entt::type_hash<std::remove_cvref_t<Type>>::value()) {
+                        if(auto other = curr.type(internal::meta_context::from(*ctx)).from_void(*ctx, nullptr, curr.cast(storage.data())); curr.id == entt::type_hash<std::remove_cvref_t<Type>>::value()) {
                             return other;
                         } else if(auto from_base = std::as_const(other).template allow_cast<Type>(); from_base) {
                             return from_base;
@@ -1062,7 +1062,7 @@ class meta_type {
 
                     if(const auto &info = other.info(); info == type.info()) {
                         ++match;
-                    } else if(!(type.fetch_node().conversion_helper && other.fetch_node().conversion_helper) && !(type.fetch_node().details && (internal::find_member<&internal::meta_base_node::type>(type.fetch_node().details->base, info.hash()) || internal::find_member<&internal::meta_conv_node::type>(type.fetch_node().details->conv, info.hash())))) {
+                    } else if(!(type.fetch_node().conversion_helper && other.fetch_node().conversion_helper) && !(type.fetch_node().details && (internal::find_member(type.fetch_node().details->base, info.hash()) || internal::find_member(type.fetch_node().details->conv, info.hash())))) {
                         break;
                     }
                 }
@@ -1113,7 +1113,7 @@ public:
      * @param curr The underlying node with which to construct the instance.
      */
     meta_type(const meta_ctx &area, const internal::meta_base_node &curr) noexcept
-        : meta_type{area, curr.resolve(internal::meta_context::from(area))} {}
+        : meta_type{area, curr.type(internal::meta_context::from(area))} {}
 
     /**
      * @brief Returns the type info object of the underlying type.
@@ -1289,12 +1289,12 @@ public:
         if(const auto &to = other.info().hash(); (info().hash() == to) || ((fetch_node().conversion_helper != nullptr) && (other.is_arithmetic() || other.is_enum()))) {
             return true;
         } else if(const auto &from = fetch_node(); from.details) {
-            if(const auto *elem = internal::find_member<&internal::meta_conv_node::type>(from.details->conv, to); elem != nullptr) {
+            if(const auto *elem = internal::find_member(from.details->conv, to); elem != nullptr) {
                 return true;
             }
 
             for(auto &&curr: from.details->base) {
-                if(curr.type == to || meta_type{*ctx, curr.resolve(internal::meta_context::from(*ctx))}.can_convert(other)) {
+                if(curr.id == to || meta_type{*ctx, curr.type(internal::meta_context::from(*ctx))}.can_convert(other)) {
                     return true;
                 }
             }
@@ -1418,7 +1418,7 @@ public:
         meta_handle wrapped{*ctx, std::forward<Instance>(instance)};
 
         if(const auto &ref = fetch_node(); ref.details) {
-            if(auto *elem = internal::find_member<&internal::meta_func_node::id>(ref.details->func, id); elem != nullptr) {
+            if(auto *elem = internal::find_member(ref.details->func, id); elem != nullptr) {
                 if(const auto *candidate = lookup(args, sz, (wrapped->base().policy() == any_policy::cref), [curr = elem]() mutable { return (curr != nullptr) ? std::exchange(curr, curr->next.get()) : nullptr; }); candidate) {
                     return candidate->invoke(std::move(wrapped), args);
                 }
@@ -1544,12 +1544,12 @@ bool meta_any::set(const id_type id, Type &&value) {
         }
 
         if(const auto &from = fetch_node(); from.details) {
-            if(const auto *elem = internal::find_member<&internal::meta_conv_node::type>(from.details->conv, type.info().hash()); elem != nullptr) {
+            if(const auto *elem = internal::find_member(from.details->conv, type.info().hash()); elem != nullptr) {
                 return elem->conv(*ctx, storage.data());
             }
 
             for(auto &&curr: from.details->base) {
-                if(auto other = curr.resolve(internal::meta_context::from(*ctx)).from_void(*ctx, nullptr, curr.cast(storage.data())); curr.type == type.info().hash()) {
+                if(auto other = curr.type(internal::meta_context::from(*ctx)).from_void(*ctx, nullptr, curr.cast(storage.data())); curr.id == type.info().hash()) {
                     return other;
                 } else if(auto from_base = std::as_const(other).allow_cast(type); from_base) {
                     return from_base;

src/entt/meta/node.hpp

@@ -66,13 +66,13 @@ struct meta_custom_node {
 };
 
 struct meta_base_node {
-    id_type type{};
-    const meta_type_node &(*resolve)(const meta_context &) noexcept {};
+    id_type id{};
+    const meta_type_node &(*type)(const meta_context &) noexcept {};
     const void *(*cast)(const void *) noexcept {};
 };
 
 struct meta_conv_node {
-    id_type type{};
+    id_type id{};
     meta_any (*conv)(const meta_ctx &, const void *){};
 };
 
@@ -146,10 +146,10 @@ struct meta_type_node {
     std::unique_ptr<meta_type_descriptor> details{};
 };
 
-template<auto Member, typename Type, typename Value>
+template<typename Type, typename Value>
 [[nodiscard]] auto *find_member(Type &from, const Value value) {
     for(auto &&elem: from) {
-        if((elem.*Member) == value) {
+        if(elem.id == value) {
             return &elem;
         }
     }
@@ -167,13 +167,13 @@ template<auto Member>
     using value_type = std::remove_reference_t<decltype((node.details.get()->*Member))>::value_type;
 
     if(node.details) {
-        if(auto *member = find_member<&value_type::id>((node.details.get()->*Member), id); member != nullptr) {
+        if(auto *member = find_member((node.details.get()->*Member), id); member != nullptr) {
             return member;
         }
 
         if(recursive) {
             for(auto &&curr: node.details->base) {
-                if(auto *elem = look_for<Member>(context, curr.resolve(context), id, recursive); elem) {
+                if(auto *elem = look_for<Member>(context, curr.type(context), id, recursive); elem) {
                     return elem;
                 }
             }
@@ -197,9 +197,9 @@ template<typename... Args>
 [[nodiscard]] inline const void *try_cast(const meta_context &context, const meta_type_node &from, const id_type to, const void *instance) noexcept {
     if(from.details) {
         for(auto &&curr: from.details->base) {
-            if(const void *other = curr.cast(instance); curr.type == to) {
+            if(const void *other = curr.cast(instance); curr.id == to) {
                 return other;
-            } else if(const void *elem = try_cast(context, curr.resolve(context), to, other); elem) {
+            } else if(const void *elem = try_cast(context, curr.type(context), to, other); elem) {
                 return elem;
             }
         }

src/entt/meta/range.hpp

@@ -73,8 +73,6 @@ struct meta_range_iterator final {
     [[nodiscard]] constexpr reference operator[](const difference_type value) const noexcept {
         if constexpr(std::is_same_v<It, typename meta_context::container_type::const_iterator>) {
             return {it[value].first, Type{*ctx, *it[value].second}};
-        } else if constexpr(std::is_same_v<typename std::iterator_traits<It>::value_type, meta_base_node>) {
-            return {it[value].type, Type{*ctx, it[value]}};
         } else {
             return {it[value].id, Type{*ctx, it[value]}};
         }