document.hpp

Go to the documentation of this file.

#pragma once
#include <algorithm>
#include <cstddef>
#include <meta>
#include <string>
#include <vector>
 
#include <welder/containers.hpp> // is_reference_container / container_kind_of
#include <welder/naming.hpp>     // restyle / case_kind (name derivation)
#include <welder/reflect.hpp>    // welded_for (element eligibility)

 
namespace welder::inline v0::rods::opaque_containers {
 
// --- type spelling & name derivation (consteval) ----------------------------

consteval std::string container_spelling(std::meta::info type) {
    return std::string{std::meta::display_string_of(std::meta::dealias(type))};
}

consteval std::size_t value_arg_count(std::meta::info type) {
    return ::welder::container_kind_of(type) == ::welder::container_kind::map ? 2u : 1u;
}

consteval std::string sanitize_ident(std::string s) {
    std::string out{};
    bool pending_sep{false};
    for (char c : s) {
        const bool ok{(c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') ||
                      (c >= '0' && c <= '9') || c == '_'};
        if (ok) {
            if (pending_sep && !out.empty())
                out += '_';
            out += c;
            pending_sep = false;
        } else {
            pending_sep = true; // collapse a run of non-identifier chars into one '_'
        }
    }
    if (out.empty())
        out = "T";
    if (out[0] >= '0' && out[0] <= '9')
        out.insert(out.begin(), '_');
    return out;
}

consteval std::string qualified_ident(std::meta::info entity) {
    auto keep = [](std::meta::info p) {
        if (!std::meta::has_identifier(p))
            return false; // anonymous namespace: nothing to spell
        const std::string id{std::meta::identifier_of(p)};
        if (id == "std")
            return false; // std::vector<int> should read VectorInt, not StdVectorInt
        return !(id.size() >= 2 && id[0] == '_' && id[1] == '_'); // __cxx11, __1, …
    };
    std::vector<std::string> parts{};
    parts.push_back(::welder::naming::restyle(
        std::meta::has_identifier(entity)
            ? std::string{std::meta::identifier_of(entity)}
            : std::string{std::meta::display_string_of(entity)},
        ::welder::naming::case_kind::pascal));
    // Walk enclosing scopes. A fundamental type (int, double) has no parent —
    // `parent_of` THROWS there, so gate every step on `has_parent`.
    for (std::meta::info e{entity};
         std::meta::has_parent(e) && std::meta::parent_of(e) != ^^::;) {
        e = std::meta::parent_of(e);
        if (!(std::meta::is_namespace(e) ||
              (std::meta::is_type(e) && std::meta::is_class_type(e))))
            break; // a function/block scope etc. — stop qualifying
        if (keep(e))
            parts.push_back(::welder::naming::restyle(
                std::string{std::meta::identifier_of(e)},
                ::welder::naming::case_kind::pascal));
    }
    std::string out{};
    for (auto it{parts.rbegin()}; it != parts.rend(); ++it)
        out += *it;
    return out;
}

consteval std::string derive_name(std::meta::info arg) {
    // A non-type (NTTP) template argument is a value, not a type — render its display
    // (e.g. `ClientVersion{3,3,5,12340}`); the caller's final sanitize legalizes it.
    if (!std::meta::is_type(arg))
        return std::string{std::meta::display_string_of(arg)};
    const std::meta::info type{std::meta::dealias(arg)};
    // std::string (and wstring, …) is basic_string<Char, …> — fold to a clean word.
    if (std::meta::has_template_arguments(type) &&
        std::meta::template_of(type) == ^^std::basic_string)
        return "String";
    if (::welder::is_reference_container(type)) {
        std::string out{qualified_ident(std::meta::template_of(type))};
        const auto args{std::meta::template_arguments_of(type)};
        for (std::size_t i{0}, n{value_arg_count(type)}; i < n; ++i)
            out += derive_name(args[i]);
        return out;
    }
    // Any OTHER class-template specialization: recurse structurally over ALL its
    // arguments (template name + each arg), so an NTTP / nested specialization reduces
    // to identifier tokens rather than a raw template-id spelling.
    if (std::meta::has_template_arguments(type)) {
        std::string out{qualified_ident(std::meta::template_of(type))};
        for (const std::meta::info a : std::meta::template_arguments_of(type))
            out += derive_name(a);
        return out;
    }
    // A plain type: its qualified identifier (namespaces + enclosing classes), or its
    // display for an unnameable one (the caller's final sanitize legalizes either).
    return qualified_ident(type);
}

consteval bool has_opaque_hook(std::meta::info style_type) {
    const std::meta::access_context ctx{std::meta::access_context::unprivileged()};
    for (const std::meta::info m : std::meta::members_of(style_type, ctx))
        if (std::meta::is_function(m) && std::meta::has_identifier(m) &&
            std::meta::identifier_of(m) == "transform_opaque_container")
            return true;
    for (const std::meta::info b : std::meta::bases_of(style_type, ctx))
        if (has_opaque_hook(std::meta::type_of(b)))
            return true;
    return false;
}

template <class Style, std::meta::info Enclosing, std::meta::info Container,
          std::meta::info Member>
consteval std::string opaque_name() {
    if constexpr (has_opaque_hook(^^Style))
        return sanitize_ident(std::string{
            Style::transform_opaque_container(Enclosing, Container, Member)});
    else
        return sanitize_ident(derive_name(Container));
}

consteval std::string namespace_name(std::meta::info ns) {
    std::string tail{std::meta::identifier_of(ns)};
    for (std::meta::info p{std::meta::parent_of(ns)};
         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;
}
 
// --- collecting the reference containers within a surface type --------------

consteval bool scalar_leaf(std::meta::info t) {
    t = std::meta::dealias(t);
    if (std::meta::is_fundamental_type(t))
        return true;
    return std::meta::has_template_arguments(t) &&
           std::meta::template_of(t) == ^^std::basic_string;
}

consteval bool element_ok(std::meta::info t) {
    t = std::meta::dealias(t);
    if (scalar_leaf(t))
        return true;
    if (is_reference_container(t)) // nested container — inner is not a predeclared name
        return false;
    if (std::meta::is_class_type(t) || std::meta::is_enum_type(t))
        // top-level (namespace-scoped) welded type => predeclared in phase 1
        // (is_namespace, not !is_class_type: is_class_type THROWS on a namespace)
        return std::meta::is_namespace(std::meta::parent_of(t)) &&
               ::welder::welded_for(t, lang::py);
    return false;
}

consteval bool opaque_eligible(std::meta::info type) {
    const auto args{std::meta::template_arguments_of(type)};
    for (std::size_t i{0}, n{value_arg_count(type)}; i < n; ++i)
        if (!element_ok(args[i]))
            return false;
    return true;
}

consteval void collect_into(std::vector<std::meta::info>& out, std::meta::info type) {
    const std::meta::info u{std::meta::dealias(std::meta::remove_cvref(type))};
    if (::welder::is_reference_container(u) && opaque_eligible(u))
        out.push_back(u);
}

template <std::meta::info Type>
consteval std::vector<std::meta::info> containers_in() {
    std::vector<std::meta::info> out{};
    collect_into(out, Type);
    return out;
}
 
// --- the growing generated header -------------------------------------------

struct entry {
    std::string spelling; 
    std::string name;     
    bool excluded;        
    bool styled;          
};

struct document {
    std::vector<entry> entries{}; 

    template <std::meta::info C, class Style, std::meta::info Enclosing,
              std::meta::info Site>
    void add_one(bool excluded, bool styled_site) {
        const char* sp{std::define_static_string(container_spelling(C))};
        const char* nm{std::define_static_string(opaque_name<Style, Enclosing, C, Site>())};
        for (entry& e : entries)
            if (e.spelling == sp) {
                e.excluded = e.excluded || excluded;
                if (styled_site && !e.styled) { // a Style-aware name beats a default one
                    e.name = nm;
                    e.styled = true;
                }
                return;
            }
        entries.push_back({std::string{sp}, std::string{nm}, excluded, styled_site});
    }

    template <std::meta::info SurfaceType, class Style, std::meta::info Enclosing,
              std::meta::info Site>
    void collect([[maybe_unused]] bool excluded, [[maybe_unused]] bool styled_site) {
        // Unused when SurfaceType names no eligible container (the common case — the
        // template for below is then empty); [[maybe_unused]] keeps -Wunused quiet.
        template for (constexpr auto c :
                      std::define_static_array(containers_in<SurfaceType>()))
            add_one<c, Style, Enclosing, Site>(excluded, styled_site);
    }

    template <std::meta::info Fn, class Style>
    void collect_callable(bool styled_site) {
        template for (constexpr auto p :
                      std::define_static_array(std::meta::parameters_of(Fn)))
            collect<std::meta::type_of(p), Style, std::meta::parent_of(Fn), Fn>(
                false, styled_site);
        if constexpr (!std::meta::is_constructor(Fn)) {
            using R = [:std::meta::return_type_of(Fn):];
            if constexpr (!std::is_void_v<R>)
                collect<std::meta::return_type_of(Fn), Style, std::meta::parent_of(Fn),
                        Fn>(false, styled_site);
        }
    }

    std::string render(const std::string& ns) const {
        std::vector<entry> es{entries};
        std::sort(es.begin(), es.end(),
                  [](const entry& a, const entry& b) { return a.name < b.name; });
        for (std::size_t i{1}; i < es.size(); ++i)
            if (!es[i].excluded && !es[i - 1].excluded &&
                es[i].name == es[i - 1].name &&
                es[i].spelling != es[i - 1].spelling)
                return "#error welder: two distinct opaque containers derive the "
                       "same name '" +
                       es[i].name + "' (" + es[i - 1].spelling + " vs " +
                       es[i].spelling +
                       "); this generator cannot rename them automatically.\n";
        std::string out{};
        out += "#pragma once\n";
        out += "// AUTO-GENERATED by welder (welder::rods::opaque_containers). 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}/rod.hpp>, before the module.\n";
        out += "#include <map>\n#include <string>\n#include <unordered_map>\n#include <vector>\n\n";
        for (const entry& e : es)
            if (!e.excluded)
                out += "WELDER_OPAQUE(" + e.spelling + ")\n";
        out += "\nnamespace " + ns + " {\n";
        for (const entry& e : es)
            if (!e.excluded)
                out += "using " + e.name +
                       " [[=welder::weld(welder::lang::py)]] = " + e.spelling + ";\n";
        out += "} // namespace " + ns + "\n";
        return out;
    }
};
 
} // namespace welder::inline v0::rods::opaque_containers