document.hpp

Go to the documentation of this file.

#pragma once
#include <cstddef>
#include <meta>
#include <string>
 
#include <welder/rods/python/trampoline.hpp> // overridable_virtuals / bound_flat

 
namespace welder::inline v0::rods::trampolines {
 
// --- small consteval text helpers -------------------------------------------

consteval std::string int_string(std::size_t n) {
    if (n == 0)
        return "0";
    std::string s{};
    for (; n; n /= 10)
        s.insert(s.begin(), char('0' + n % 10));
    return s;
}

consteval bool cpp_spellable(std::meta::info ent) {
    if (!std::meta::has_identifier(ent))
        return false;
    for (std::meta::info p{std::meta::parent_of(ent)};
         p != std::meta::info{} && p != ^^::; p = std::meta::parent_of(p))
        if (!std::meta::has_identifier(p))
            return false;
    return true;
}

consteval std::string cpp_qualified_name(std::meta::info ent) {
    std::string tail{};
    if (std::meta::has_identifier(ent))
        tail = std::meta::identifier_of(ent);
    for (std::meta::info p{std::meta::parent_of(ent)};
         p != std::meta::info{} && p != ^^:: && std::meta::has_identifier(p);
         p = std::meta::parent_of(p))
        tail = std::string{std::meta::identifier_of(p)} + "::" + tail;
    return "::" + tail;
}

consteval std::string trampoline_ident(std::meta::info type) {
    std::string s{};
    if (std::meta::has_identifier(type))
        s = std::meta::identifier_of(type);
    for (std::meta::info p{std::meta::parent_of(type)};
         p != std::meta::info{} && p != ^^:: && std::meta::has_identifier(p);
         p = std::meta::parent_of(p))
        s = std::string{std::meta::identifier_of(p)} + "_" + s;
    return s + "_trampoline";
}

consteval bool is_c_variadic(std::meta::info fn) {
    std::string s{std::meta::display_string_of(std::meta::type_of(fn))};
    return s.find("...") != std::string::npos;
}

consteval std::string qualifier_tokens(std::meta::info fn) {
    std::string q{};
    if (std::meta::is_const(fn))
        q += " const";
    if (std::meta::is_volatile(fn))
        q += " volatile";
    if (std::meta::is_lvalue_reference_qualified(fn))
        q += " &";
    if (std::meta::is_rvalue_reference_qualified(fn))
        q += " &&";
    if (std::meta::is_noexcept(fn))
        q += " noexcept";
    return q;
}

inline constexpr const char* generated_namespace{
    "::welder::rods::trampolines::generated"};

consteval std::string render_trampoline(std::meta::info type) {
    const std::string base{cpp_qualified_name(type)};
    const std::string ident{trampoline_ident(type)};
    std::string s{};
    s += "struct " + ident + " : " + base + " {\n";
    s += "    WELDER_PY_TRAMPOLINE(" + ident + ", " + base + ");\n";
 
    std::size_t k{0};
    for (auto slot : ::welder::overridable_virtuals(type)) {
        const std::string name{std::meta::identifier_of(slot)};
        if (is_c_variadic(slot)) {
            s += "    static_assert(false, \"welder: '" + base + "::" + name +
                 "' is a C-variadic virtual; C++26 reflection cannot reproduce its "
                 "'...' parameter. Mark it "
                 "[[=welder::bind_flat]] to bind it non-overridably.\");\n";
            ++k; // keep k aligned with the overridable_virtuals index for later slots
            continue;
        }
        // The reflected slot, re-derived in the generated TU (same order as here).
        const std::string idx{"::welder::overridable_virtuals(^^" + base +
                              ")[" + int_string(k) + "]"};
        s += "    [: ::std::meta::return_type_of(" + idx + ") :] " + name + "(";
        std::string args{};
        std::size_t j{0};
        for (auto p : std::meta::parameters_of(slot)) {
            (void)p;
            if (j) {
                s += ", ";
                args += ", ";
            }
            const std::string js{int_string(j)};
            s += "[: ::std::meta::type_of(::std::meta::parameters_of(" + idx + ")[" +
                 js + "]) :] a" + js;
            args += "a" + js;
            ++j;
        }
        // The slot-taking macro form: dispatch keys on the slot's reflection (never
        // `^^Base::name`, which is ill-formed for an overloaded virtual), while the
        // textual name spells the qualified base fallback, where overload resolution
        // picks the right overload from the forwarded parameters.
        s += ")" + qualifier_tokens(slot) + " override { WELDER_PY_OVERRIDE_AS((" +
             idx + "), " + name + (args.empty() ? "" : ", " + args) + "); }\n";
        ++k;
    }
    s += "};\n";
    return s;
}

consteval std::string render_registration(std::meta::info type) {
    return "template <> constexpr ::std::meta::info\n"
           "    ::welder::rods::python::trampoline_for<" +
           cpp_qualified_name(type) + "> = ^^" + generated_namespace +
           "::" + trampoline_ident(type) + ";\n";
}

struct document {
    std::string structs{};        
    std::string registrations{};  

    template <std::meta::info Type>
    void add() {
        // The generated text must SPELL the type in C++ (base clause, the
        // trampoline_for key, the slot re-derivations) — impossible for a bare
        // class-template specialization, which has no identifier and whose
        // template-id cannot be respelled faithfully from reflection. The alias
        // is that spelling: welding `using IntRing = Ring<int>;` in the swept
        // namespace routes the carriage here with the alias as @a Type.
        static_assert(std::meta::has_identifier(Type),
                      "welder: cannot generate a trampoline for a class-template "
                      "specialization spelled directly (it has no identifier); "
                      "declare a namespace-scope alias — using IntRing = "
                      "Ring<int>; — and weld that instead");
        // The identifier check above covers the type itself; the chain check
        // covers a nameable type nested inside an UNNAMEABLE scope — a virtual
        // type declared inside a class-template specialization — whose
        // qualified spelling would otherwise silently truncate to broken C++.
        static_assert(
            cpp_spellable(Type),
            "welder: cannot generate a trampoline for a type nested inside a "
            "class-template specialization (its enclosing scope cannot be "
            "respelled from reflection). Hand-write the trampoline, spelling "
            "the base through the welding alias (e.g. `struct PyValve : "
            "IntSilo::Valve { … }` with a trampoline_for specialization), or "
            "annotate the type [[=welder::bind_flat]].");
        structs += std::define_static_string(render_trampoline(Type));
        registrations += std::define_static_string(render_registration(Type));
    }

    std::string render() const {
        std::string out{};
        out += "#pragma once\n";
        out += "// AUTO-GENERATED by welder (welder::rods::trampolines). Do not edit.\n";
        out += "//\n";
        out += "// Include AFTER your welded type headers and the active backend's\n";
        out += "// <welder/rods/python/{pybind11,nanobind}/trampoline.hpp>.\n";
        out += "#include <meta>\n";
        out += "#include <welder/rods/python/trampoline.hpp>\n\n";
        out += "namespace welder::rods::trampolines::generated {\n\n";
        out += structs;
        out += "\n} // namespace welder::rods::trampolines::generated\n\n";
        out += registrations;
        return out;
    }
};
 
} // namespace welder::rods::trampolines