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/virtuals.hpp>   // the neutral slot machinery (welder::virtual_slot, ...)
#include <welder/vocabulary.hpp> // the annotation vocabulary (for structural specs)

 
namespace welder::inline v0::rods::python {
 
// The backend-neutral slot machinery (bind_flat, overridable_virtuals,
// virtual_slot, ...) is language-neutral — the C# rod's directors consume the
// same answers — and lives at welder:: scope in <welder/virtuals.hpp> (spell
// it [[=welder::bind_flat]], welder::virtual_slot(...), ...).
 
// --- 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;
}

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