bind_traits.hpp

Go to the documentation of this file.

#pragma once
#include <array>
#include <cstddef>
#include <meta>
#include <string_view>
#include <type_traits>
#include <vector>
 
#include <welder/diag.hpp>    // the consteval diagnostics (stale_hook_signature)
#include <welder/reflect.hpp> // resolution: welded_for / member_bound / public_bases

 
namespace welder::inline v0::detail {
 
// --- function / parameter introspection -------------------------------------

template <std::meta::info Fn>
consteval auto param_types() {
    constexpr std::size_t n{std::meta::parameters_of(Fn).size()};
    std::array<std::meta::info, n> types{};
    std::size_t i{0};
    for (auto p : std::meta::parameters_of(Fn))
        types[i++] = std::meta::type_of(p);
    return types;
}

template <std::meta::info Fn>
consteval auto param_names() {
    constexpr std::size_t n{std::meta::parameters_of(Fn).size()};
    std::array<const char*, n> names{};
    std::size_t i{0};
    for (auto p : std::meta::parameters_of(Fn))
        names[i++] = std::meta::has_identifier(p)
                         ? std::define_static_string(std::meta::identifier_of(p))
                         : nullptr;
    return names;
}

struct keep_alive_pair {
    unsigned nurse;   
    unsigned patient; 
};

template <std::meta::info Fn>
consteval auto keep_alive_pairs() {
    constexpr std::size_t n{
        std::meta::annotations_of_with_type(Fn, ^^keep_alive_spec).size()};
    std::array<keep_alive_pair, n> out{};
    if constexpr (n != 0) {
        std::size_t i{0};
        for (auto a : std::meta::annotations_of_with_type(Fn, ^^keep_alive_spec)) {
            auto s{std::meta::extract<keep_alive_spec>(a)};
            out[i++] = {s.nurse, s.patient};
        }
    }
    return out;
}

template <std::meta::info Fn>
consteval bool all_params_named() {
    for (auto p : std::meta::parameters_of(Fn))
        if (!std::meta::has_identifier(p))
            return false;
    return true;
}
 
// --- constructor / method / operator eligibility ----------------------------

consteval bool is_bindable_constructor(std::meta::info c) {
    return std::meta::is_constructor(c) && std::meta::is_public(c) &&
           !std::meta::is_deleted(c) && !std::meta::is_copy_constructor(c) &&
           !std::meta::is_move_constructor(c) &&
           !std::meta::parameters_of(c).empty();
}

consteval bool is_method_candidate(std::meta::info f) {
    return std::meta::is_function(f) && !std::meta::is_constructor(f) &&
           !std::meta::is_special_member_function(f) &&
           !std::meta::is_destructor(f) && !std::meta::is_operator_function(f) &&
           !std::meta::is_private(f) && !std::meta::is_deleted(f);
}

consteval bool is_operator_candidate(std::meta::info f) {
    return std::meta::is_function(f) && std::meta::is_operator_function(f) &&
           !std::meta::is_special_member_function(f) &&
           !std::meta::is_private(f) && !std::meta::is_deleted(f);
}

template <class Resolution>
consteval bool member_access_admitted(std::meta::info mem, lang L,
                                      std::meta::info bound_into) {
    if (std::meta::is_public(mem))
        return true;
    if (!std::meta::is_protected(mem))
        return false; // private (or inaccessible): out by design, always
    if constexpr (requires {
                      Resolution::protected_participates(mem, L, bound_into);
                  }) {
        return Resolution::protected_participates(mem, L, bound_into);
    } else if constexpr (requires {
                             Resolution::protected_participates(mem, L);
                         }) {
        // A pre-bound_into hook: hard-error rather than silently ignore it.
        throw ::welder::diag::stale_hook_signature{};
    } else {
        return ::welder::protected_welded(std::meta::parent_of(mem), L);
    }
}

template <std::meta::info Mem>
struct field_access {
    using class_type = typename [:std::meta::parent_of(Mem):];
    using field_type = typename [:std::meta::type_of(Mem):];

    static const field_type& get(const class_type& c) { return c.[:Mem:]; }
    static void set(class_type& c, const field_type& v) { c.[:Mem:] = v; }
};

consteval bool is_unary_operator(std::meta::info f) {
    return std::meta::parameters_of(f).empty();
}
 
// --- aggregate initialization -----------------------------------------------
//
// An aggregate (a simple POD-like struct: no user-declared constructors) cannot
// be constructed as T(a, b) — only brace-initialized T{a, b}. A backend may want
// to synthesize a field constructor so the target language can build it with
// values; these helpers decide when that is valid and expose the fields.

template <class T>
consteval auto aggregate_fields() {
    constexpr auto ctx{std::meta::access_context::unchecked()};
    constexpr std::size_t n{std::meta::nonstatic_data_members_of(^^T, ctx).size()};
    std::array<std::meta::info, n> fs{};
    // Guard the fill: std::array<T, 0>::operator[] is not usable (its size-0
    // trap overload is not consteval, so merely instantiating it with the
    // consteval-only std::meta::info is an error for a fieldless type).
    if constexpr (n != 0) {
        std::size_t i{0};
        for (auto m : std::meta::nonstatic_data_members_of(^^T, ctx))
            fs[i++] = m;
    }
    return fs;
}

template <class T, lang L, class Resolution>
consteval bool aggregate_initializable() {
    if (!std::is_aggregate_v<T> || !welder::public_bases(^^T).empty())
        return false;
    constexpr auto ctx{std::meta::access_context::unchecked()};
    auto fields{std::meta::nonstatic_data_members_of(^^T, ctx)};
    if (fields.empty())
        return false;
    const policy_kind pol{policy_of(^^T)};
    for (auto m : fields)
        if (!Resolution::class_member_participates(m, L, pol, ^^T))
            return false;
    return true;
}
 
// --- namespace-member eligibility -------------------------------------------

consteval bool is_bindable_kind(std::meta::info mem) {
    return (std::meta::is_type(mem) &&
            (std::meta::is_class_type(mem) || std::meta::is_enum_type(mem))) ||
           std::meta::is_function(mem) || std::meta::is_variable(mem);
}

consteval bool entity_bound(std::meta::info mem, lang L, policy_kind pol) {
    return is_bindable_kind(mem) && welded_for(mem, L) && member_bound(mem, L, pol);
}

consteval bool namespace_has_bound(std::meta::info ns, lang L) {
    constexpr auto ctx{std::meta::access_context::unchecked()};
    const policy_kind pol{policy_of(ns)};
    for (auto mem : std::meta::members_of(ns, ctx)) {
        if (std::meta::is_namespace(mem)) {
            if (member_bound(mem, L, pol) && namespace_has_bound(mem, L))
                return true;
        } else if (entity_bound(mem, L, pol)) {
            return true;
        }
    }
    return false;
}

consteval bool namespace_has_bindable(std::meta::info ns, lang L) {
    constexpr auto ctx{std::meta::access_context::unchecked()};
    const policy_kind pol{policy_of(ns)};
    for (auto mem : std::meta::members_of(ns, ctx)) {
        if (std::meta::is_namespace(mem)) {
            if (member_bound(mem, L, pol) && namespace_has_bindable(mem, L))
                return true;
        } else if (is_bindable_kind(mem) && member_bound(mem, L, pol)) {
            return true;
        }
    }
    return false;
}
 
// --- overload groups (resolution-aware) ---------------------------------------
//
// Several target frameworks store ONE entity per name — a Lua table key, a
// LuaCATS `function` declaration — so a name's C++ overloads must arrive as one
// group. The CARRIAGE owns that grouping (it visits a group's first participating
// overload, the *leader*, computes the whole set with these selectors and hands
// it to the rod's group hook): the rods never re-derive membership, so a group is
// exactly what the resolution admits — per-overload marks and bespoke
// (signature-level) resolutions stay consistent across every rod, and a mixed
// welded/unwelded set under one name can never split into clobbering halves.

template <class Resolution>
consteval std::vector<std::meta::info> method_overload_set(
    std::meta::info fn, lang L, std::meta::info bound_into) {
    const std::meta::info cls{std::meta::parent_of(fn)};
    const policy_kind pol{::welder::policy_of(cls)};
    const auto name{std::meta::identifier_of(fn)};
    const bool is_static{std::meta::is_static_member(fn)};
    std::vector<std::meta::info> out{};
    for (auto m : std::meta::members_of(cls, std::meta::access_context::unchecked()))
        if (is_method_candidate(m) &&
            member_access_admitted<Resolution>(m, L, bound_into) &&
            Resolution::class_member_participates(m, L, pol, bound_into) &&
            std::meta::is_static_member(m) == is_static &&
            std::meta::identifier_of(m) == name)
            out.push_back(m);
    return out;
}

template <class Resolution>
consteval std::vector<std::meta::info> operator_overload_set(
    std::meta::info fn, lang L, std::meta::info bound_into) {
    const std::meta::info cls{std::meta::parent_of(fn)};
    const policy_kind pol{::welder::policy_of(cls)};
    std::vector<std::meta::info> out{};
    for (auto m : std::meta::members_of(cls, std::meta::access_context::unchecked()))
        if (is_operator_candidate(m) &&
            member_access_admitted<Resolution>(m, L, bound_into) &&
            Resolution::class_member_participates(m, L, pol, bound_into) &&
            std::meta::operator_of(m) == std::meta::operator_of(fn) &&
            is_unary_operator(m) == is_unary_operator(fn))
            out.push_back(m);
    return out;
}

template <class Resolution>
consteval std::vector<std::meta::info> function_overload_set(
    std::meta::info fn, lang L, std::meta::info bound_into) {
    const std::meta::info ns{std::meta::parent_of(fn)};
    const policy_kind pol{::welder::policy_of(ns)};
    const auto name{std::meta::identifier_of(fn)};
    std::vector<std::meta::info> out{};
    for (auto m : std::meta::members_of(ns, std::meta::access_context::unchecked()))
        if (std::meta::is_function(m) &&
            Resolution::member_participates(m, L, pol, bound_into) &&
            std::meta::identifier_of(m) == name)
            out.push_back(m);
    return out;
}

using overload_selector =
    std::vector<std::meta::info> (*)(std::meta::info, lang, std::meta::info);

template <overload_selector Select, std::meta::info Fn, lang L,
          std::meta::info BoundInto>
consteval auto overload_group() {
    constexpr std::size_t n{Select(Fn, L, BoundInto).size()};
    std::array<std::meta::info, n> out{};
    // Guard the fill: std::array<T, 0>::operator[] is not usable (n is >= 1 for a
    // group leader, but the guard keeps this well-formed regardless).
    if constexpr (n != 0) {
        auto v{Select(Fn, L, BoundInto)};
        for (std::size_t i{0}; i < n; ++i)
            out[i] = v[i];
    }
    return out;
}

template <overload_selector Select>
consteval bool is_overload_leader(std::meta::info fn, lang L,
                                  std::meta::info bound_into) {
    auto v{Select(fn, L, bound_into)};
    return !v.empty() && v.front() == fn;
}

template <class Resolution, std::meta::info Fn, lang L>
consteval auto manual_function_group() {
    if constexpr (!std::meta::has_identifier(Fn)) {
        return std::array<std::meta::info, 1>{Fn};
    } else {
        constexpr std::size_t n{[] {
            auto v{function_overload_set<Resolution>(Fn, L,
                                                     std::meta::parent_of(Fn))};
            std::size_t extra{1};
            for (auto m : v)
                if (m == Fn)
                    extra = 0;
            return v.size() + extra;
        }()};
        std::array<std::meta::info, n> out{};
        out[0] = Fn;
        std::size_t i{1};
        for (auto m :
             function_overload_set<Resolution>(Fn, L, std::meta::parent_of(Fn)))
            if (m != Fn)
                out[i++] = m;
        return out;
    }
}

template <class Resolution, std::meta::info Type, lang L, policy_kind Pol>
consteval auto ctor_group() {
    constexpr auto ctx{std::meta::access_context::unchecked()};
    constexpr std::size_t n{[] {
        std::size_t count{0};
        for (auto c : std::meta::members_of(Type, ctx))
            if (is_bindable_constructor(c) &&
                Resolution::class_member_participates(c, L, Pol, Type))
                ++count;
        return count;
    }()};
    std::array<std::meta::info, n> out{};
    if constexpr (n != 0) {
        std::size_t i{0};
        for (auto c : std::meta::members_of(Type, ctx))
            if (is_bindable_constructor(c) &&
                Resolution::class_member_participates(c, L, Pol, Type))
                out[i++] = c;
    }
    return out;
}

template <class Resolution, std::meta::info Type, lang L>
consteval bool default_ctor_admitted() {
    constexpr auto ctx{std::meta::access_context::unchecked()};
    for (auto c : std::meta::members_of(Type, ctx))
        if (std::meta::is_constructor(c) && std::meta::parameters_of(c).empty())
            return std::meta::is_public(c) && !std::meta::is_deleted(c) &&
                   Resolution::class_member_participates(
                       c, L, policy_kind::automatic, Type);
    return true; // implicit (or absent): constructibility alone decides
}
 
// --- inheritance: native bases ----------------------------------------------
//
// `weld` marks a type as an independently-registered, module-discoverable entity,
// NOT as an inheritance directive. The most-derived type's `weld` drives which
// languages bind; a base need not be welded to contribute its members. Two kinds
// of public base fall out for a binding:
//   * a welded base -> registered as its own target-language class, linked via
//     native inheritance (passed as a base of the derived class handle).
//   * a non-welded base -> a plain C++ mixin with no standalone type, whose
//     eligible members are flattened onto the derived binding.

consteval void collect_native_bases(std::meta::info type, lang L,
                                    std::vector<std::meta::info>& out) {
    for (auto base : welder::public_bases(type)) {
        if (welder::welded_for(base, L)) {
            bool seen{false};
            for (auto e : out)
                if (e == base) {
                    seen = true;
                    break;
                }
            if (!seen)
                out.push_back(base);
        } else {
            collect_native_bases(base, L, out); // descend through the mixin
        }
    }
}

template <std::meta::info Type, lang L>
consteval auto native_base_types() {
    constexpr std::size_t n{[] {
        std::vector<std::meta::info> v;
        collect_native_bases(Type, L, v);
        return v.size();
    }()};
    std::array<std::meta::info, n> types{};
    // Guard the fill: std::array<T, 0>::operator[] is not consteval, so it must
    // not be instantiated when a type has no native bases (the common case).
    if constexpr (n != 0) {
        std::vector<std::meta::info> v;
        collect_native_bases(Type, L, v);
        std::size_t i{0};
        for (auto base : v)
            types[i++] = base;
    }
    return types;
}
 
} // namespace welder::detail