virtuals.hpp

Go to the documentation of this file.

#pragma once
#include <cstddef>
#include <meta>
#include <string_view>
#include <vector>
 
#include <welder/diag.hpp> // no_matching_virtual_slot

 
namespace welder::inline v0 {
 
// --- bind_flat: opt out of trampoline support for a virtual type -------------

struct bind_flat_spec {};

inline constexpr bind_flat_spec bind_flat{};

consteval bool bound_flat(std::meta::info entity) {
    return !std::meta::annotations_of_with_type(entity, ^^bind_flat_spec).empty();
}
 
// --- virtual-method reflection ----------------------------------------------

consteval bool is_overridable_virtual(std::meta::info member) {
    return std::meta::is_function(member) && std::meta::is_virtual(member) &&
           !std::meta::is_destructor(member) && !bound_flat(member);
}
 
namespace detail {

consteval bool same_slot(std::meta::info a, std::meta::info b) {
    if (std::meta::identifier_of(a) != std::meta::identifier_of(b))
        return false;
    if (std::meta::is_const(a) != std::meta::is_const(b) ||
        std::meta::is_volatile(a) != std::meta::is_volatile(b) ||
        std::meta::is_lvalue_reference_qualified(a) !=
            std::meta::is_lvalue_reference_qualified(b) ||
        std::meta::is_rvalue_reference_qualified(a) !=
            std::meta::is_rvalue_reference_qualified(b))
        return false;
    auto pa{std::meta::parameters_of(a)};
    auto pb{std::meta::parameters_of(b)};
    if (pa.size() != pb.size())
        return false;
    for (std::size_t i{0}; i < pa.size(); ++i)
        if (std::meta::type_of(pa[i]) != std::meta::type_of(pb[i]))
            return false;
    return true;
}

consteval void collect_virtuals(std::meta::info type,
                                std::vector<std::meta::info>& slots) {
    for (auto m :
         std::meta::members_of(type, std::meta::access_context::unchecked())) {
        if (!std::meta::is_function(m) || !std::meta::is_virtual(m) ||
            std::meta::is_destructor(m) || !std::meta::has_identifier(m))
            continue;
        bool seen{false};
        for (auto s : slots)
            if (same_slot(s, m)) {
                seen = true;
                break;
            }
        if (!seen)
            slots.push_back(m);
    }
    for (auto b :
         std::meta::bases_of(type, std::meta::access_context::unchecked()))
        collect_virtuals(std::meta::dealias(std::meta::type_of(b)), slots);
}
 
} // namespace detail

consteval std::vector<std::meta::info> overridable_virtuals(std::meta::info type) {
    // Accept an alias reflection too (the spelling a generated trampoline uses for
    // a class-template specialization): the walk needs the underlying class.
    type = std::meta::dealias(type);
    std::vector<std::meta::info> all{};
    detail::collect_virtuals(type, all);
    std::vector<std::meta::info> out{};
    for (auto s : all)
        if (!bound_flat(s) && !std::meta::is_private(s))
            out.push_back(s);
    return out;
}

consteval std::meta::info virtual_slot(std::meta::info type, std::string_view name,
                                       std::meta::info fn_type) {
    for (auto s : overridable_virtuals(type))
        if (std::meta::identifier_of(s) == name &&
            std::meta::type_of(s) == std::meta::dealias(fn_type))
            return s;
    throw diag::no_matching_virtual_slot{};
}

consteval std::size_t virtual_slot_count(std::meta::info type) {
    return overridable_virtuals(type).size();
}

consteval bool has_virtual_methods(std::meta::info type) {
    return !overridable_virtuals(type).empty();
}
 
} // namespace welder::inline v0