reflect.hpp

Go to the documentation of this file.

#pragma once
#include <meta>
#include <string> // accessor_explicit_name
 
#include <welder/diag.hpp>

 
namespace welder::inline v0 {

consteval bool weld_mask_admits(unsigned mask, lang L) {
    return mask == 0 || (mask & lang_bit(L)) != 0;
}

consteval bool welded_for(std::meta::info type, lang L) {
    auto anns{std::meta::annotations_of_with_type(type, ^^detail::weld_spec)};
    return !anns.empty() &&
           weld_mask_admits(std::meta::extract<detail::weld_spec>(anns[0]).mask, L);
}

consteval bool flags_enum(std::meta::info type) {
    return !std::meta::annotations_of_with_type(type, ^^detail::flags_spec).empty();
}

consteval bool names_template_specialization(std::meta::info mem) {
    return std::meta::is_type_alias(mem) &&
           std::meta::is_class_type(std::meta::dealias(mem)) &&
           std::meta::has_template_arguments(std::meta::dealias(mem));
}

consteval bool alias_welded_for(std::meta::info mem, lang L) {
    auto own{std::meta::annotations_of_with_type(mem, ^^detail::weld_spec)};
    if (!own.empty())
        return weld_mask_admits(
            std::meta::extract<detail::weld_spec>(own[0]).mask, L);
    return welded_for(std::meta::dealias(mem), L);
}

consteval bool alias_marks_admissible(std::meta::info mem) {
    for (auto a : std::meta::annotations_of(mem)) {
        auto t{std::meta::type_of(a)};
        if (t == ^^detail::policy_spec || t == ^^detail::weld_protected_spec ||
            t == ^^detail::exclude_spec || t == ^^detail::include_spec ||
            t == ^^detail::only_spec || t == ^^detail::trust_bindable_spec ||
            t == ^^detail::return_policy_spec || t == ^^detail::keep_alive_spec ||
            t == ^^detail::accessor_spec)
            return false;
        if (std::meta::has_template_arguments(t)) {
            auto tmpl{std::meta::template_of(t)};
            if (tmpl == ^^detail::doc_spec || tmpl == ^^detail::return_doc_spec ||
                tmpl == ^^detail::tparam_spec)
                return false;
        }
    }
    return true;
}

consteval bool member_alias_marks_admissible(std::meta::info mem) {
    for (auto a : std::meta::annotations_of(mem)) {
        auto t{std::meta::type_of(a)};
        if (t == ^^detail::weld_spec || t == ^^detail::policy_spec ||
            t == ^^detail::weld_protected_spec ||
            t == ^^detail::trust_bindable_spec ||
            t == ^^detail::return_policy_spec || t == ^^detail::keep_alive_spec ||
            t == ^^detail::accessor_spec)
            return false;
        if (std::meta::has_template_arguments(t)) {
            auto tmpl{std::meta::template_of(t)};
            if (tmpl == ^^detail::doc_spec || tmpl == ^^detail::return_doc_spec ||
                tmpl == ^^detail::tparam_spec)
                return false;
        }
    }
    return true;
}

consteval policy_kind policy_of(std::meta::info type) {
    auto anns{std::meta::annotations_of_with_type(type, ^^detail::policy_spec)};
    return anns.empty() ? policy_kind::automatic
                        : std::meta::extract<detail::policy_spec>(anns[0]).kind;
}

consteval bool protected_welded(std::meta::info type, lang L) {
    for (auto a : std::meta::annotations_of_with_type(
             type, ^^detail::weld_protected_spec)) {
        auto s{std::meta::extract<detail::weld_protected_spec>(a)};
        if (s.mask == 0 || (s.mask & lang_bit(L)) != 0)
            return true;
    }
    return false;
}

consteval bool excluded_for(std::meta::info member, lang L) {
    for (auto a : std::meta::annotations_of_with_type(member, ^^detail::exclude_spec)) {
        auto s{std::meta::extract<detail::exclude_spec>(a)};
        if (s.mask == 0 || (s.mask & lang_bit(L)) != 0)
            return true;
    }
    return false;
}

consteval bool included_for(std::meta::info member, lang L) {
    for (auto a : std::meta::annotations_of_with_type(member, ^^detail::include_spec)) {
        auto s{std::meta::extract<detail::include_spec>(a)};
        if (s.mask == 0 || (s.mask & lang_bit(L)) != 0)
            return true;
    }
    return false;
}

consteval bool trusted_for(std::meta::info member, lang L) {
    for (auto a : std::meta::annotations_of_with_type(member, ^^detail::trust_bindable_spec)) {
        auto s{std::meta::extract<detail::trust_bindable_spec>(a)};
        if (s.mask == 0 || (s.mask & lang_bit(L)) != 0)
            return true;
    }
    return false;
}

consteval bool member_no_reassign(std::meta::info member, lang L) {
    for (auto a : std::meta::annotations_of_with_type(member, ^^detail::no_reassign_spec)) {
        auto s{std::meta::extract<detail::no_reassign_spec>(a)};
        if (s.mask == 0 || (s.mask & lang_bit(L)) != 0)
            return true;
    }
    return false;
}

consteval bool has_no_reassign_mark(std::meta::info entity) {
    return !std::meta::annotations_of_with_type(entity, ^^detail::no_reassign_spec)
                .empty();
}

consteval bool accessor_marked(std::meta::info member, accessor_role role, lang L) {
    for (auto a : std::meta::annotations_of_with_type(member, ^^detail::accessor_spec)) {
        auto s{std::meta::extract<detail::accessor_spec>(a)};
        if (s.role == role && (s.mask == 0 || (s.mask & lang_bit(L)) != 0))
            return true;
    }
    return false;
}

consteval bool is_accessor_for(std::meta::info member, lang L) {
    return accessor_marked(member, accessor_role::getter, L) ||
           accessor_marked(member, accessor_role::setter, L);
}

consteval bool has_accessor_mark(std::meta::info member) {
    return !std::meta::annotations_of_with_type(member, ^^detail::accessor_spec)
                .empty();
}

consteval std::string accessor_explicit_name(std::meta::info member,
                                             accessor_role role, lang L) {
    for (auto a : std::meta::annotations_of_with_type(member, ^^detail::accessor_spec)) {
        auto s{std::meta::extract<detail::accessor_spec>(a)};
        if (s.role == role && (s.mask == 0 || (s.mask & lang_bit(L)) != 0) &&
            s.name[0] != '\0')
            return std::string{s.name};
    }
    return {};
}

consteval rv_kind return_policy_of(std::meta::info fn, lang L) {
    for (auto a : std::meta::annotations_of_with_type(fn, ^^detail::return_policy_spec)) {
        auto s{std::meta::extract<detail::return_policy_spec>(a)};
        if (s.mask == 0 || (s.mask & lang_bit(L)) != 0)
            return s.kind;
    }
    return rv_kind::automatic;
}

template <std::meta::info Fn, lang L>
consteval void validate_return_policy() {
    constexpr rv_kind k{return_policy_of(Fn, L)};
    if constexpr (k == rv_kind::reference || k == rv_kind::reference_internal) {
        constexpr std::meta::info rt{std::meta::return_type_of(Fn)};
        if constexpr (!(std::meta::is_pointer_type(rt) ||
                        std::meta::is_lvalue_reference_type(rt) ||
                        std::meta::is_rvalue_reference_type(rt)))
            throw diag::dangling_return_policy{};
    }
}

consteval bool member_bound(std::meta::info member, lang L, policy_kind pol) {
    if (excluded_for(member, L))
        return false;
    auto onlys{std::meta::annotations_of_with_type(member, ^^detail::only_spec)};
    if (!onlys.empty()) {
        unsigned mask{0};
        for (auto a : onlys) {
            auto s{std::meta::extract<detail::only_spec>(a)};
            if (s.mask == 0)
                throw diag::bare_mark_only{};
            mask |= s.mask;
        }
        return (mask & lang_bit(L)) != 0;
    }
    if (pol == policy_kind::automatic)
        return true;
    return included_for(member, L) || is_accessor_for(member, L);
}

consteval std::vector<std::meta::info> public_bases(std::meta::info type) {
    std::vector<std::meta::info> out;
    constexpr auto ctx{std::meta::access_context::unchecked()};
    for (auto b : std::meta::bases_of(type, ctx))
        if (std::meta::is_public(b))
            out.push_back(std::meta::type_of(b));
    return out;
}
 
} // namespace welder