trampoline.hpp

Go to the documentation of this file.

#pragma once
#include <cstddef>
#include <meta>
#include <string_view>
#include <vector>
 
#include <welder/diag.hpp>       // the consteval diagnostics (no_matching_virtual_slot)
#include <welder/vocabulary.hpp> // the annotation vocabulary (for structural specs)

 
namespace welder::inline v0::rods::python {
 
// --- 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();
}
 
// --- trampoline registration -------------------------------------------------

template <class T>
constexpr std::meta::info trampoline_for = std::meta::info{};
 
// --- trampoline discovery by annotation -------------------------------------

struct trampoline_spec {};

inline constexpr trampoline_spec trampoline{};

consteval bool is_trampoline(std::meta::info type) {
    return !std::meta::annotations_of_with_type(type, ^^trampoline_spec).empty();
}

struct scanned_trampoline {
    std::meta::info type{};  
    bool ambiguous{false};   
};

consteval scanned_trampoline scanned_trampoline_of(std::meta::info base) {
    scanned_trampoline result{};
    for (auto mem : std::meta::members_of(std::meta::parent_of(base),
                                          std::meta::access_context::current())) {
        if (mem == base || !std::meta::is_type(mem) || !is_trampoline(mem))
            continue;
        for (auto b :
             std::meta::bases_of(mem, std::meta::access_context::current())) {
            if (std::meta::dealias(std::meta::type_of(b)) ==
                std::meta::dealias(base)) {
                if (result.type != std::meta::info{})
                    result.ambiguous = true;
                else
                    result.type = mem;
                break;
            }
        }
    }
    return result;
}
 
// --- 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 ::welder::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();
}

template <class T>
consteval std::meta::info construction_type_of() {
    if (trampoline_for<T> != std::meta::info{})
        return trampoline_for<T>;
    // Only a virtual type can carry a trampoline — skip the namespace scan otherwise.
    if (has_virtual_methods(^^T))
        if (auto scanned{scanned_trampoline_of(^^T)};
            scanned.type != std::meta::info{})
            return scanned.type;
    return ^^T;
}

consteval bool declares_override(std::meta::info tramp, std::meta::info vfn) {
    auto name{std::meta::identifier_of(vfn)};
    auto sig{std::meta::type_of(vfn)};
    for (auto m :
         std::meta::members_of(tramp, std::meta::access_context::unchecked())) {
        if (std::meta::is_function(m) && !std::meta::is_special_member_function(m) &&
            std::meta::identifier_of(m) == name && std::meta::type_of(m) == sig) {
            return true;
        }
    }
    return false;
}

consteval bool trampoline_covers(std::meta::info type, std::meta::info tramp) {
    for (auto m : overridable_virtuals(type))
        if (!declares_override(tramp, m))
            return false;
    return true;
}
 
} // namespace welder::rods::python