bind_traits.hpp

Go to the documentation of this file.

#pragma once
#include <array>
#include <cstddef>
#include <cstdint>
#include <meta>
#include <sstream> // std::ostream (the stringifier-shape test) + stringify's stream
#include <string>
#include <string_view>
#include <type_traits>
#include <vector>
 
#include <welder/diag.hpp>    // the consteval diagnostics (stale_hook_signature)
#include <welder/naming.hpp>  // property naming: accessor_property_words / strip_accessor_word
#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 std::size_t trailing_default_count() {
    auto ps = std::meta::parameters_of(Fn);
    std::size_t n{0};
    for (std::size_t i = ps.size(); i > 0; --i) {
        if (!std::meta::has_default_argument(ps[i - 1]))
            break;
        ++n;
    }
    return n;
}

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);
}
 
// --- freestanding (namespace-scope) operators --------------------------------
//
// A free operator is part of a type's interface exactly as a member one is (C++
// finds it by ADL), so welder sweeps a welded type's enclosing namespace for
// operators *anchored* on the type — one operand IS the type — and folds them
// into the type's binding. Hidden friends are the one shape reflection cannot
// see (P2996 enumerates neither a class's friends nor ADL): move them to
// namespace scope, or bind them by hand on the returned class handle.

consteval bool decays_to(std::meta::info t, std::meta::info type) {
    return std::meta::dealias(std::meta::remove_cvref(t)) ==
           std::meta::dealias(type);
}

consteval bool is_free_operator_candidate(std::meta::info f) {
    return std::meta::is_function(f) && std::meta::is_operator_function(f) &&
           !std::meta::is_class_member(f) && !std::meta::is_deleted(f);
}

consteval bool is_stringifier_for(std::meta::info f, std::meta::info type) {
    if (!is_free_operator_candidate(f) ||
        std::meta::operator_of(f) != std::meta::operators::op_less_less)
        return false;
    auto ps{std::meta::parameters_of(f)};
    if (ps.size() != 2)
        return false;
    const auto p0{std::meta::type_of(ps[0])};
    return std::meta::is_lvalue_reference_type(p0) &&
           decays_to(p0, ^^std::ostream) &&
           decays_to(std::meta::type_of(ps[1]), type);
}

consteval bool free_operator_anchored(std::meta::info f, std::meta::info type) {
    if (!is_free_operator_candidate(f) || is_stringifier_for(f, type))
        return false;
    for (auto p : std::meta::parameters_of(f)) {
        const auto t{std::meta::type_of(p)};
        if (decays_to(t, type) && !std::meta::is_rvalue_reference_type(t))
            return true;
    }
    return false;
}

consteval bool free_operator_reflected(std::meta::info f, std::meta::info type) {
    if (std::meta::is_class_member(f))
        return false;
    auto ps{std::meta::parameters_of(f)};
    return ps.size() == 2 && !decays_to(std::meta::type_of(ps[0]), type);
}

template <auto Fns, std::meta::info Type, bool Reflected>
consteval auto partition_reflected() {
    constexpr std::size_t n{[] {
        std::size_t c{0};
        for (auto f : Fns)
            if (free_operator_reflected(f, Type) == Reflected)
                ++c;
        return c;
    }()};
    std::array<std::meta::info, n> out{};
    // Guard the fill: std::array<T, 0>::operator[] is not consteval.
    if constexpr (n != 0) {
        std::size_t i{0};
        for (auto f : Fns)
            if (free_operator_reflected(f, Type) == Reflected)
                out[i++] = f;
    }
    return out;
}

consteval std::meta::info enclosing_namespace(std::meta::info type) {
    auto p{std::meta::parent_of(type)};
    while (!std::meta::is_namespace(p))
        p = std::meta::parent_of(p);
    return p;
}

consteval std::meta::info comparison_operand(std::meta::info f,
                                             std::meta::info type) {
    for (auto p : std::meta::parameters_of(f))
        if (!decays_to(std::meta::type_of(p), type))
            return std::meta::type_of(p);
    return type; // homogeneous: every operand is the type itself
}

template <auto Fns, std::meta::info Type>
consteval bool has_heterogeneous_comparison() {
    for (auto f : Fns)
        if (!decays_to(comparison_operand(f, Type), Type))
            return true;
    return false;
}

enum class cmp_slot : std::uint8_t { lt = 0, le = 1, gt = 2, ge = 3 };
template <class A, class B, cmp_slot S>
struct synthesized_comparison {
    static bool call(const A& a, const B& b) {
        if constexpr (S == cmp_slot::lt)
            return a < b;
        else if constexpr (S == cmp_slot::le)
            return a <= b;
        else if constexpr (S == cmp_slot::gt)
            return a > b;
        else
            return a >= b;
    }
};

template <class T, std::meta::info Fn>
std::string stringify(const T& self) {
    std::ostringstream os{};
    [:Fn:](os, self);
    return os.str();
}

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) {
    const std::size_t n{std::meta::parameters_of(f).size()};
    return (std::meta::is_class_member(f) && !std::meta::is_static_member(f))
               ? n == 0
               : n == 1;
}
 
// --- 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) {
        // An UNNAMED field (an anonymous union, an unnamed bit-field) is
        // structurally unbindable — the member sweep skips it — so it counts
        // as non-participating here: synthesizing a field constructor would
        // leak it as a positional parameter (aggregate init is positional and
        // all-or-nothing).
        if (!std::meta::has_identifier(m))
            return false;
        if (!Resolution::class_member_participates(m, L, pol, ^^T))
            return false;
    }
    return true;
}

template <class T>
consteval std::size_t aggregate_required_arity() {
    constexpr auto fields{aggregate_fields<T>()};
    std::size_t required{0};
    // Guard the indexing: std::array<info, 0>::operator[] is not consteval, so
    // it must not be instantiated for a fieldless type (same trap as the
    // aggregate_fields fill).
    if constexpr (fields.size() != 0) {
        for (std::size_t i{0}; i < fields.size(); ++i)
            if (!std::meta::has_default_member_initializer(fields[i]))
                required = i + 1;
    }
    return required;
}

template <class T>
consteval std::size_t aggregate_defaults_from() {
    constexpr auto fields{aggregate_fields<T>()};
    if (!std::meta::is_default_constructible_type(^^T))
        return fields.size();
    std::size_t from{aggregate_required_arity<T>()};
    // Guarded indexing, as in aggregate_required_arity.
    if constexpr (fields.size() != 0) {
        for (std::size_t i{from}; i < fields.size(); ++i)
            if (!std::meta::is_copy_constructible_type(
                    std::meta::type_of(fields[i])))
                from = i + 1;
    }
    return from;
}
 
// --- 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) &&
            !::welder::is_accessor_for(m, L) &&
            std::meta::is_static_member(m) == is_static &&
            std::meta::identifier_of(m) == name)
            out.push_back(m);
    return out;
}

template <class Resolution>
consteval void collect_member_operators(std::meta::info src, lang L,
                                        std::meta::info bound_into,
                                        std::vector<std::meta::info>& out) {
    for (auto base : ::welder::public_bases(src))
        if (!Resolution::is_native_base(base, L, src))
            collect_member_operators<Resolution>(base, L, bound_into, out);
    const policy_kind pol{::welder::policy_of(src)};
    for (auto m :
         std::meta::members_of(src, 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))
            out.push_back(m);
}

template <class Resolution>
consteval std::vector<std::meta::info> operator_entries(std::meta::info type,
                                                        lang L) {
    std::vector<std::meta::info> out{};
    collect_member_operators<Resolution>(type, L, type, out);
    const policy_kind pol{::welder::policy_of(type)};
    for (auto m : std::meta::members_of(enclosing_namespace(type),
                                        std::meta::access_context::unchecked()))
        if (free_operator_anchored(m, type) &&
            Resolution::class_member_participates(m, L, pol, type))
            out.push_back(m);
    return out;
}

template <class Resolution>
consteval std::vector<std::meta::info> operator_slot_set(
    std::meta::info fn, lang L, std::meta::info bound_into) {
    std::vector<std::meta::info> out{};
    for (auto m : operator_entries<Resolution>(bound_into, L))
        if (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> stringifier_entries(std::meta::info type,
                                                           lang L) {
    std::vector<std::meta::info> out{};
    const policy_kind pol{::welder::policy_of(type)};
    for (auto m : std::meta::members_of(enclosing_namespace(type),
                                        std::meta::access_context::unchecked()))
        if (is_stringifier_for(m, type) &&
            Resolution::class_member_participates(m, L, pol, type))
            out.push_back(m);
    return out;
}

template <class Resolution>
consteval std::array<bool, 4> covered_comparison_slots(std::meta::info type,
                                                       lang L) {
    std::array<bool, 4> covered{};
    for (auto m : operator_entries<Resolution>(type, L)) {
        if (is_unary_operator(m))
            continue;
        switch (std::meta::operator_of(m)) {
            case std::meta::operators::op_less:
                covered[0] = true;
                break;
            case std::meta::operators::op_less_equals:
                covered[1] = true;
                break;
            case std::meta::operators::op_greater:
                covered[2] = true;
                break;
            case std::meta::operators::op_greater_equals:
                covered[3] = true;
                break;
            default:
                break;
        }
    }
    return covered;
}

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
}

template <class Resolution, std::meta::info Type, lang L>
consteval bool copy_ctor_admitted() {
    constexpr auto ctx{std::meta::access_context::unchecked()};
    bool declared{false};
    for (auto c : std::meta::members_of(Type, ctx))
        if (std::meta::is_copy_constructor(c)) {
            declared = true;
            if (std::meta::is_public(c) && !std::meta::is_deleted(c) &&
                Resolution::class_member_participates(
                    c, L, policy_kind::automatic, Type))
                return true;
        }
    return !declared; // implicit: constructibility alone decides
}

template <std::meta::info Type>
consteval void validate_move_ctor_marks() {
    constexpr auto ctx{std::meta::access_context::unchecked()};
    for (auto c : std::meta::members_of(Type, ctx))
        if (std::meta::is_move_constructor(c) &&
            (!std::meta::annotations_of_with_type(c, ^^include_spec).empty() ||
             !std::meta::annotations_of_with_type(c, ^^only_spec).empty()))
            throw diag::marked_move_constructor{};
}
 
// --- method-backed properties (getter / setter marks) -------------------------
//
// A `[[=welder::getter]]` / `[[=welder::setter]]` member function binds as an
// idiomatic PROPERTY instead of a method, for the languages its mark covers.
// The machinery here mirrors the operator slot story: accessors are collected
// once per welded type across the flattening walk (own members + non-native
// bases'), validated, PAIRED by property name — the case-normalized word
// sequence of the explicit name or the get/set-stripped identifier, so the
// overload style (radius()/radius(double)), the prefix styles (get_x/set_x,
// getX/setX, GetX/SetX) and even mixed conventions all pair — and handed to the
// rod one resolved property at a time (add_property<T, Getter, Setter>). The
// method sweep skips accessor-marked functions for the covered languages (see
// method_overload_set / the carriage's bind_members); for languages a mark does
// not cover, the function binds as an ordinary method.

struct property_entry {
    std::meta::info getter{}; 
    std::meta::info setter{}; 
};

consteval bool carries_weld_as(std::meta::info m) {
    for (auto a : std::meta::annotations_of(m)) {
        auto t{std::meta::type_of(a)};
        if (std::meta::has_template_arguments(t) &&
            std::meta::template_of(t) == ^^weld_as_spec)
            return true;
    }
    return false;
}

consteval std::vector<std::string> property_key(std::meta::info mem,
                                                accessor_role role, lang L) {
    std::string explicit_name{::welder::accessor_explicit_name(mem, role, L)};
    if (!explicit_name.empty())
        return naming::split_words(explicit_name);
    return naming::accessor_property_words(std::meta::identifier_of(mem));
}

template <class Resolution>
consteval void collect_accessors(std::meta::info src, lang L,
                                 std::meta::info bound_into,
                                 std::vector<std::meta::info>& out) {
    for (auto base : ::welder::public_bases(src))
        if (!Resolution::is_native_base(base, L, src))
            collect_accessors<Resolution>(base, L, bound_into, out);
    const policy_kind pol{::welder::policy_of(src)};
    for (auto m :
         std::meta::members_of(src, 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) &&
            ::welder::is_accessor_for(m, L))
            out.push_back(m);
}

template <class Resolution>
consteval void validate_property_shadowing(
    std::meta::info src, lang L, std::meta::info bound_into,
    const std::vector<std::vector<std::string>>& keys) {
    for (auto base : ::welder::public_bases(src))
        if (!Resolution::is_native_base(base, L, src))
            validate_property_shadowing<Resolution>(base, L, bound_into, keys);
    constexpr auto ctx{std::meta::access_context::unchecked()};
    const policy_kind pol{::welder::policy_of(src)};
    auto clashes{[&](std::meta::info m) {
        const auto words{naming::split_words(std::meta::identifier_of(m))};
        for (const auto& k : keys)
            if (k == words)
                return true;
        return false;
    }};
    for (auto m : std::meta::nonstatic_data_members_of(src, ctx))
        if (std::meta::has_identifier(m) &&
            member_access_admitted<Resolution>(m, L, bound_into) &&
            Resolution::class_member_participates(m, L, pol, bound_into) &&
            clashes(m))
            throw diag::property_name_collision{};
    for (auto m : std::meta::members_of(src, ctx))
        if (is_method_candidate(m) &&
            member_access_admitted<Resolution>(m, L, bound_into) &&
            Resolution::class_member_participates(m, L, pol, bound_into) &&
            !::welder::is_accessor_for(m, L) && clashes(m))
            throw diag::property_name_collision{};
}

template <class Resolution>
consteval std::vector<property_entry> property_entries(std::meta::info type,
                                                       lang L) {
    std::vector<std::meta::info> acc{};
    collect_accessors<Resolution>(type, L, type, acc);
 
    for (auto m : acc) {
        if (::welder::accessor_marked(m, accessor_role::getter, L) &&
            ::welder::accessor_marked(m, accessor_role::setter, L))
            throw diag::accessor_role_conflict{};
        if (std::meta::is_static_member(m))
            throw diag::static_property_accessor{};
        if (std::meta::is_virtual(m))
            throw diag::virtual_property_accessor{};
        if (carries_weld_as(m))
            throw diag::accessor_weld_as_conflict{};
    }
 
    std::vector<property_entry> props{};
    std::vector<std::vector<std::string>> keys{};
    for (auto m : acc) {
        if (!::welder::accessor_marked(m, accessor_role::getter, L))
            continue;
        if (!std::meta::parameters_of(m).empty() ||
            std::meta::dealias(std::meta::return_type_of(m)) == ^^void ||
            !std::meta::is_const(m) ||
            std::meta::is_rvalue_reference_qualified(m))
            throw diag::malformed_getter{};
        auto key{property_key(m, accessor_role::getter, L)};
        for (const auto& k : keys)
            if (k == key)
                throw diag::duplicate_property_accessor{};
        props.push_back({m, std::meta::info{}});
        keys.push_back(std::move(key));
    }
    for (auto m : acc) {
        if (!::welder::accessor_marked(m, accessor_role::setter, L))
            continue;
        if (std::meta::parameters_of(m).size() != 1 ||
            std::meta::is_rvalue_reference_qualified(m))
            throw diag::malformed_setter{};
        const auto key{property_key(m, accessor_role::setter, L)};
        bool matched{false};
        for (std::size_t i{0}; i < keys.size(); ++i) {
            if (keys[i] != key)
                continue;
            if (props[i].setter != std::meta::info{})
                throw diag::duplicate_property_accessor{};
            props[i].setter = m;
            matched = true;
            break;
        }
        if (!matched)
            throw diag::setter_without_getter{};
    }
 
    validate_property_shadowing<Resolution>(type, L, type, keys);
    return props;
}

template <std::meta::info Getter, lang L, class Style>
consteval const char* property_bound_name() {
    constexpr std::string_view explicit_name{std::define_static_string(
        ::welder::accessor_explicit_name(Getter, accessor_role::getter, L))};
    if constexpr (!explicit_name.empty())
        return explicit_name.data();
    else
        return std::define_static_string(
            naming::strip_accessor_word(Style::transform_field(Getter)));
}
 
// --- 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