rod.hpp

Go to the documentation of this file.

#pragma once
#include <array>
#include <cstddef>
#include <meta>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>
 
#include <welder/welder.hpp>              // welder::welder + rod contract + driver
#include <welder/rods/lua/metamethods.hpp> // shared operator -> Lua __name map
#include <welder/bind_traits.hpp>         // aggregate_* helpers
 
// LuaBridge3 requires the Lua headers to be visible first (its Config.h hard-errors
// otherwise). Pull them in here so a binding TU only needs this rod header, the way
// the sol2 rod gets Lua transitively through <sol/sol.hpp>. lua.hpp is the C++
// convenience wrapper every PUC-Lua / LuaJIT distribution ships.
#include <lua.hpp>
 
#include <LuaBridge/LuaBridge.h>
 
// Make every C++ enum convert to/from a Lua integer. By default LuaBridge3 treats
// an unspecialized type as userdata, so an enum-typed function parameter/return
// would demand a registered userdata; welder instead binds an enum as a table of
// integer values (see make_enum), so its values cross the boundary as integers.
// This blanket specialization — the generalization of LuaBridge3's opt-in
// `Stack<E> = Enum<E>` — makes that work for any welded enum without per-enum glue.
namespace luabridge {
template <class E>
struct Stack<E, std::enable_if_t<std::is_enum_v<E>>> : Enum<E> {};
} // namespace luabridge
 
namespace welder::inline v0::rods::luabridge {
 
// The welder rod namespace `welder::rods::luabridge` would shadow the library's
// `::luabridge`, so alias it (as the Python rods alias pybind11/nanobind) and use
// `lb::` throughout.
namespace lb = ::luabridge;
 
using ::welder::rods::lua::lua_metamethod_name;

template <class... A>
using ctor_sig = void(A...);

template <class T, class... A>
T make_object(A... args) {
    return T(std::move(args)...);
}

struct rod {
    static constexpr lang language{lang::lua}; 

    struct module_scope {
        lua_State* L{nullptr};             
        std::vector<std::string> path{};   
    };
    using module_type = module_scope;          

    struct session {};

    template <class T>
    struct class_handle {
        using type = T;      
        module_scope mod;    
        std::string name;    
    };

    struct enum_handle {
        module_scope mod;
        std::string name;
        bool scoped;
        std::string outer_key{};
    };

    template <class T> using class_handle_type = class_handle<T>;
    template <class> using enum_handle_type = enum_handle;
 
  protected:
    // --- implementation helpers (not part of the welder::rod contract) --

    template <class T>
    static constexpr bool _needs_registration =
        std::is_enum_v<std::remove_cvref_t<T>> ||
        lb::detail::IsUserdata<std::remove_cvref_t<T>>::value;

    template <class H>
    using _class_type = typename std::remove_cvref_t<H>::type;

    static lb::Namespace _open_namespace(const module_scope& m) {
        lb::Namespace ns{lb::getGlobalNamespace(m.L)};
        for (const auto& seg : m.path)
            ns = ns.beginNamespace(seg.c_str());
        return ns;
    }

    template <class T>
    static auto _open_class(const module_scope& m, const char* name) {
        return _open_namespace(m).template beginClass<T>(name);
    }

    static void _push_module_table(const module_scope& m) {
        lua_pushglobaltable(m.L);
        for (const auto& seg : m.path) {
            lua_pushlstring(m.L, seg.data(), seg.size());
            lua_rawget(m.L, -2);
            lua_remove(m.L, -2);
        }
    }

    template <class T, auto Ctors, bool HasDefault, bool Aggregate>
    static consteval std::vector<std::vector<std::meta::info>> _ctor_arg_lists() {
        std::vector<std::vector<std::meta::info>> lists;
        if (HasDefault)
            lists.push_back({}); // ()
        for (auto c : Ctors) {
            std::vector<std::meta::info> args;
            for (auto p : std::meta::parameters_of(c))
                args.push_back(std::meta::type_of(p));
            lists.push_back(args);
        }
        // constexpr-if: the branch indexes the field array, which must not be
        // instantiated for a fieldless type (the array<info, 0> trap) — and
        // Aggregate guarantees at least one field.
        if constexpr (Aggregate) {
            // One arity per omissible NSDMI-suffix tail (aggregate_required_arity):
            // C++26 parenthesized aggregate init fills omitted trailing fields
            // from their NSDMIs, so T(prefix…) is valid for every prefix length
            // down to the required arity. Arity 0 would duplicate the default
            // constructor's signature, so it starts at 1 when that is bound.
            auto fields{::welder::detail::aggregate_fields<T>()};
            std::size_t start{::welder::detail::aggregate_required_arity<T>()};
            if (HasDefault && start == 0)
                start = 1;
            for (std::size_t arity{start}; arity <= fields.size(); ++arity) {
                std::vector<std::meta::info> args;
                for (std::size_t i{0}; i < arity; ++i)
                    args.push_back(std::meta::type_of(fields[i]));
                lists.push_back(args);
            }
        }
        return lists;
    }

    template <class T, auto Ctors, bool HasDefault, bool Aggregate>
    static consteval auto _ctor_sigs_array() {
        constexpr std::size_t n{
            _ctor_arg_lists<T, Ctors, HasDefault, Aggregate>().size()};
        std::array<std::meta::info, n> out{};
        if constexpr (n != 0) {
            auto lists{_ctor_arg_lists<T, Ctors, HasDefault, Aggregate>()};
            for (std::size_t i{0}; i < n; ++i)
                out[i] = std::meta::dealias(std::meta::substitute(^^ctor_sig, lists[i]));
        }
        return out;
    }

    template <class T, auto Ctors, bool HasDefault, bool Aggregate>
    static consteval auto _factory_array() {
        constexpr std::size_t n{
            _ctor_arg_lists<T, Ctors, HasDefault, Aggregate>().size()};
        std::array<std::meta::info, n> out{};
        if constexpr (n != 0) {
            auto lists{_ctor_arg_lists<T, Ctors, HasDefault, Aggregate>()};
            for (std::size_t i{0}; i < n; ++i) {
                std::vector<std::meta::info> targs{^^T};
                for (auto a : lists[i])
                    targs.push_back(a);
                out[i] = std::meta::substitute(^^make_object, targs);
            }
        }
        return out;
    }

    template <auto Sigs, auto Factories, class Cls, std::size_t... I>
    static void _add_constructors(Cls& cls, std::index_sequence<I...>) {
        cls.template addConstructor<typename [:Sigs[I]:]...>();
        cls.addStaticFunction("new", &[:Factories[I]:]...);
    }

    template <class T, auto Bases, std::size_t... I>
    static void _make_class(const module_scope& m, const char* name,
                            std::index_sequence<I...>) {
        if constexpr (sizeof...(I) == 0) {
            auto cls{_open_namespace(m).template beginClass<T>(name)};
        } else {
            auto cls{_open_namespace(m)
                         .template deriveClass<T, typename [:Bases[I]:]...>(name)};
        }
    }

    template <auto Grp, class Target, std::size_t... I>
    static void _add_function(Target& t, const char* name,
                              std::index_sequence<I...>) {
        // LuaBridge3 owns a returned object structurally (a value → a Lua-owned
        // copy; a pointer/reference → a non-owning view), so a
        // [[=welder::return_policy]] has no runtime effect here — but a
        // self-contradictory one (a reference to a returned temporary) is still
        // rejected, uniformly with the Python rods.
        (::welder::validate_return_policy<Grp[I], language>(), ...);
        t.addFunction(name, &[:Grp[I]:]...);
    }

    template <auto Grp, class Target, std::size_t... I>
    static void _add_static_function(Target& t, const char* name,
                                     std::index_sequence<I...>) {
        (::welder::validate_return_policy<Grp[I], language>(), ...);
        t.addStaticFunction(name, &[:Grp[I]:]...);
    }
 
  public:
    // --- caster oracle + emission primitives (the welder::rod contract) --

    template <class T>
    static constexpr bool has_native_caster = !_needs_registration<T>;

    static consteval const char* special_method_name(std::meta::info op_fn) {
        return lua_metamethod_name(op_fn);
    }
 
    // --- class binding ------------------------------------------------------

    template <class T, auto Bases, std::size_t... I>
    static class_handle<T> make_class(module_type& m, const char* name,
                                      const char* /*doc*/,
                                      std::index_sequence<I...> /*seq*/) {
        _make_class<T, Bases>(m, name, std::make_index_sequence<Bases.size()>{});
        return class_handle<T>{m, std::string{name}};
    }

    template <class T, auto Bases, std::size_t... I>
    static class_handle<T> make_nested_class(module_type&, auto& outer,
                                             const char* name, const char* /*doc*/,
                                             std::index_sequence<I...> /*seq*/) {
        std::string temp{outer.name + "." + name};
        _make_class<T, Bases>(outer.mod, temp.c_str(),
                              std::make_index_sequence<Bases.size()>{});
        return class_handle<T>{outer.mod, std::move(temp)};
    }

    template <class T>
    static void finish_nested_class(module_type&, auto& outer, auto& cls,
                                    const char* name) {
        lua_State* L{cls.mod.L};
        _push_module_table(cls.mod);                            // [mod]
        lua_pushlstring(L, cls.name.data(), cls.name.size());
        lua_rawget(L, -2);                                      // [mod, inner]
        lua_pushlstring(L, outer.name.data(), outer.name.size());
        lua_rawget(L, -3);                                      // [mod, inner, outerT]
        lua_pushstring(L, name);
        lua_pushvalue(L, -3);                                   // [.., outerT, name, inner]
        lua_rawset(L, -3);                                      // outerT[name] = inner
        lua_pop(L, 2);                                          // [mod]
        lua_pushlstring(L, cls.name.data(), cls.name.size());
        lua_pushnil(L);
        lua_rawset(L, -3);                                      // mod["Outer.Inner"] = nil
        lua_pop(L, 1);
    }

    template <class T, auto Ctors, bool HasDefault, bool Aggregate, bool Copyable,
              class Style = ::welder::naming::none>
    static void add_constructors(auto& h) {
        constexpr auto sigs{_ctor_sigs_array<T, Ctors, HasDefault, Aggregate>()};
        constexpr auto factories{_factory_array<T, Ctors, HasDefault, Aggregate>()};
        if constexpr (sigs.size() != 0) {
            auto cls{_open_class<T>(h.mod, h.name.c_str())};
            _add_constructors<sigs, factories>(
                cls, std::make_index_sequence<sigs.size()>{});
        }
    }

    template <std::meta::info Mem, class Style = ::welder::naming::none>
    static void add_field(auto& h) {
        using T = _class_type<decltype(h)>;
        constexpr const char* name{
            ::welder::name_of<Mem, language, Style, ::welder::ent_kind::field>()};
        constexpr bool read_only{std::meta::is_const_type(std::meta::type_of(Mem)) ||
                                 ::welder::member_no_reassign(Mem, language)};
        auto cls{_open_class<T>(h.mod, h.name.c_str())};
        if constexpr (!std::meta::is_public(Mem)) {
            // A protected member (admitted under policy::weld_protected) binds
            // as a getter/setter property over welder::detail::field_access —
            // gcc-16 rejects the dependent `&[:Mem:]` for protected data (see
            // field_access).
            using fa = ::welder::detail::field_access<Mem>;
            if constexpr (read_only)
                cls.addProperty(name, &fa::get);
            else
                cls.addProperty(name, &fa::get, &fa::set);
        } else {
            using Field = typename [:std::meta::type_of(Mem):];
            constexpr Field T::* mp{&[:Mem:]};
            if constexpr (read_only)
                cls.addProperty(name, mp);      // read-only (const or no_reassign)
            else
                cls.addProperty(name, mp, mp);  // read/write
        }
    }

    template <class T, std::meta::info Getter, std::meta::info Setter>
    static void add_property(auto& h, const char* name) {
        ::welder::validate_return_policy<Getter, language>();
        auto cls{_open_class<T>(h.mod, h.name.c_str())};
        using GF = typename [:std::meta::type_of(Getter):];
        static constexpr GF T::* get{&[:Getter:]};
        if constexpr (Setter == std::meta::info{}) {
            cls.addProperty(name, get);
        } else {
            using SF = typename [:std::meta::type_of(Setter):];
            static constexpr SF T::* set{&[:Setter:]};
            if constexpr (std::meta::dealias(std::meta::return_type_of(Setter)) ==
                          ^^void) {
                cls.addProperty(name, get, set);
            } else {
                // A value-returning setter: wrap both halves as callables and
                // discard the setter's return (the property protocol has no
                // slot for it).
                using Arg = typename
                    [:std::meta::type_of(std::meta::parameters_of(Setter)[0]):];
                cls.addProperty(
                    name, [](const T* self) -> decltype(auto) { return (self->*get)(); },
                    [](T* self, Arg v) { (self->*set)(std::forward<Arg>(v)); });
            }
        }
    }

    template <auto Fns, class Style = ::welder::naming::none>
    static void add_method(auto& h) {
        using T = _class_type<decltype(h)>;
        auto cls{_open_class<T>(h.mod, h.name.c_str())};
        _add_function<Fns>(
            cls,
            ::welder::name_of<Fns[0], language, Style, ::welder::ent_kind::method>(),
            std::make_index_sequence<Fns.size()>{});
    }

    template <auto Fns, class Style = ::welder::naming::none>
    static void add_static_method(auto& h) {
        using T = _class_type<decltype(h)>;
        auto cls{_open_class<T>(h.mod, h.name.c_str())};
        _add_static_function<Fns>(
            cls,
            ::welder::name_of<Fns[0], language, Style,
                              ::welder::ent_kind::static_method>(),
            std::make_index_sequence<Fns.size()>{});
    }

    template <class T, auto Fns>
    static void add_operator(auto& h) {
        constexpr auto Fn{Fns[0]};
        {
            auto cls{_open_class<T>(h.mod, h.name.c_str())};
            if constexpr (std::meta::operator_of(Fn) ==
                          std::meta::operators::op_square_brackets) {
                using Key = std::remove_cvref_t<typename [:std::meta::type_of(
                    std::meta::parameters_of(Fn)[0]):]>;
                cls.addIndexMetaMethod(
                    +[](T& self, const lb::LuaRef& key, lua_State* L) -> lb::LuaRef {
                        if constexpr (std::is_arithmetic_v<Key>) {
                            key.push(L); // may be a stringified number (see above)
                            int is_num{0};
                            const lua_Number n{lua_tonumberx(L, -1, &is_num)};
                            lua_pop(L, 1);
                            if (!is_num)
                                return lb::LuaRef(L); // not a subscript key
                            return lb::LuaRef(L, self[static_cast<Key>(n)]);
                        } else {
                            if (auto k = key.template cast<Key>())
                                return lb::LuaRef(L, self[*k]);
                            return lb::LuaRef(L); // nil: fall through to member lookup
                        }
                    });
            } else {
                constexpr const char* slot{lua_metamethod_name(Fn)};
                constexpr auto direct{
                    ::welder::detail::partition_reflected<Fns, ^^T, false>()};
                _add_operator_slot<T, Fns, direct>(
                    cls, slot, std::make_index_sequence<direct.size()>{});
            }
        }
    }

    template <class T, auto Fns, auto Covered>
    static void add_comparisons(auto& h) {
        auto cls{_open_class<T>(h.mod, h.name.c_str())};
        constexpr auto seq{std::make_index_sequence<Fns.size()>{}};
        if constexpr (!Covered[0])
            _add_synth_cmp<T, Fns, ::welder::detail::cmp_slot::lt>(cls, "__lt",
                                                                   seq);
        if constexpr (!Covered[1])
            _add_synth_cmp<T, Fns, ::welder::detail::cmp_slot::le>(cls, "__le",
                                                                   seq);
    }

    template <class T, std::meta::info Fn>
    static void add_stringifier(auto& h) {
        auto cls{_open_class<T>(h.mod, h.name.c_str())};
        cls.addFunction("__tostring", &::welder::detail::stringify<T, Fn>);
    }
 
  private:
    template <class T, auto Fns, auto Direct, class C, std::size_t... I>
    static void _add_operator_slot(C& cls, const char* slot,
                                   std::index_sequence<I...>) {
        template for (constexpr auto fn : std::define_static_array(Fns)) {
            ::welder::validate_return_policy<fn, language>();
        }
        if constexpr (Direct.size() == Fns.size())
            cls.addFunction(slot, &[:Direct[I]:]...);
        else
            cls.addFunction(slot, &_op_dispatch<T, Fns>);
    }

    template <class T, auto Fns>
    static int _op_dispatch(lua_State* L) {
        int done{-1};
        template for (constexpr auto fn : std::define_static_array(Fns)) {
            if (done < 0)
                done = _try_operator_entry<T, fn>(L);
        }
        if (done < 0)
            return luaL_error(
                L, "welder: no matching operator overload for these operands");
        return done;
    }

    template <class T, std::meta::info Fn>
    static int _try_operator_entry(lua_State* L) {
        if (lua_gettop(L) < 2)
            return -1;
        const lb::LuaRef a{lb::LuaRef::fromStack(L, 1)};
        const lb::LuaRef b{lb::LuaRef::fromStack(L, 2)};
        if constexpr (std::meta::is_class_member(Fn)) {
            using B_ = std::remove_cvref_t<typename [:std::meta::type_of(
                std::meta::parameters_of(Fn)[0]):]>;
            const auto vb{b.template cast<B_>()};
            if (!vb)
                return -1;
            if constexpr (requires(const T& s, const B_& x) { s.[:Fn:](x); }) {
                const auto pt{a.template cast<const T*>()};
                if (!pt || *pt == nullptr)
                    return -1;
                return _push_result(L, ((**pt).[:Fn:])(*vb));
            } else {
                const auto pt{a.template cast<T*>()};
                if (!pt || *pt == nullptr)
                    return -1;
                return _push_result(L, ((**pt).[:Fn:])(*vb));
            }
        } else {
            using A_ = std::remove_cvref_t<typename [:std::meta::type_of(
                std::meta::parameters_of(Fn)[0]):]>;
            using B_ = std::remove_cvref_t<typename [:std::meta::type_of(
                std::meta::parameters_of(Fn)[1]):]>;
            const auto va{a.template cast<A_>()};
            if (!va)
                return -1;
            const auto vb{b.template cast<B_>()};
            if (!vb)
                return -1;
            return _push_result(L, [:Fn:](*va, *vb));
        }
    }

    template <class R>
    static int _push_result(lua_State* L, R&& v) {
        const auto r{lb::Stack<std::remove_cvref_t<R>>::push(
            L, std::forward<R>(v))};
        if (!r)
            return luaL_error(L, "welder: failed to push operator result");
        return 1;
    }

    template <class T, auto Fns, ::welder::detail::cmp_slot S, class C,
              std::size_t... I>
    static void _add_synth_cmp(C& cls, const char* name,
                               std::index_sequence<I...>) {
        using ::welder::detail::synthesized_comparison;
        if constexpr (::welder::detail::has_heterogeneous_comparison<Fns,
                                                                     ^^T>())
            cls.addFunction(name, &_cmp_dispatch<T, Fns, S>);
        else
            cls.addFunction(
                name,
                &synthesized_comparison<
                    T,
                    std::remove_cvref_t<typename [: ::welder::detail::
                                                        comparison_operand(
                                                            Fns[I], ^^T) :]>,
                    S>::call...);
    }

    template <class T, auto Fns, ::welder::detail::cmp_slot S>
    static int _cmp_dispatch(lua_State* L) {
        int done{-1};
        template for (constexpr auto fn : std::define_static_array(Fns)) {
            using P = std::remove_cvref_t<
                typename [: ::welder::detail::comparison_operand(fn, ^^T) :]>;
            if (done < 0)
                done = _try_cmp<T, P, S, false>(L);
            if constexpr (!std::is_same_v<P, T>) {
                if (done < 0)
                    done = _try_cmp<T, P, S, true>(L);
            }
        }
        if (done < 0)
            return luaL_error(
                L, "welder: no matching comparison for these operands");
        return done;
    }

    template <class T, class P, ::welder::detail::cmp_slot S, bool Rev>
    static int _try_cmp(lua_State* L) {
        using A_ = std::conditional_t<Rev, P, T>;
        using B_ = std::conditional_t<Rev, T, P>;
        if (lua_gettop(L) < 2)
            return -1;
        const auto va{lb::LuaRef::fromStack(L, 1).template cast<A_>()};
        if (!va)
            return -1;
        const auto vb{lb::LuaRef::fromStack(L, 2).template cast<B_>()};
        if (!vb)
            return -1;
        return _push_result(
            L, ::welder::detail::synthesized_comparison<A_, B_, S>::call(*va,
                                                                         *vb));
    }
 
  public:
    // --- enum binding -------------------------------------------------------

    template <class E>
    static enum_handle make_enum(module_type& m, const char* name,
                                 const char* /*doc*/) {
        _open_namespace(m).beginNamespace(name); // create (empty), then unwind
        return enum_handle{m, std::string{name}, std::is_scoped_enum_v<E>};
    }

    template <class E>
    static enum_handle make_nested_enum(module_type&, auto& outer,
                                        const char* name, const char* /*doc*/) {
        lua_State* L{outer.mod.L};
        _push_module_table(outer.mod);                          // [mod]
        lua_pushlstring(L, outer.name.data(), outer.name.size());
        lua_rawget(L, -2);                                      // [mod, outerT]
        lua_pushstring(L, name);
        lua_newtable(L);                                        // [.., name, values]
        lua_rawset(L, -3);                                      // outerT[name] = {}
        lua_pop(L, 2);
        return enum_handle{outer.mod, std::string{name}, std::is_scoped_enum_v<E>,
                           outer.name};
    }

    template <std::meta::info Enum, class Style = ::welder::naming::none>
    static void add_enumerator(enum_handle& e) {
        constexpr const char* name{
            ::welder::name_of<Enum, language, Style, ::welder::ent_kind::enumerator>()};
        const lua_Integer value{static_cast<lua_Integer>(std::to_underlying([:Enum:]))};
        if (e.outer_key.empty()) {
            _open_namespace(e.mod).beginNamespace(e.name.c_str()).addVariable(name, value);
            if (!e.scoped)
                _open_namespace(e.mod).addVariable(name, value);
        } else {
            // Class-nested: write through the outer's table with raw ops (the
            // value table is a raw static entry created by make_nested_enum).
            lua_State* L{e.mod.L};
            _push_module_table(e.mod);                              // [mod]
            lua_pushlstring(L, e.outer_key.data(), e.outer_key.size());
            lua_rawget(L, -2);                                      // [mod, outerT]
            lua_pushlstring(L, e.name.data(), e.name.size());
            lua_rawget(L, -2);                                      // [mod, outerT, values]
            lua_pushstring(L, name);
            lua_pushinteger(L, value);
            lua_rawset(L, -3);                                      // values[name] = v
            lua_pop(L, 1);                                          // [mod, outerT]
            if (!e.scoped) {
                lua_pushstring(L, name);
                lua_pushinteger(L, value);
                lua_rawset(L, -3);                                  // outerT[name] = v
            }
            lua_pop(L, 2);
        }
    }

    template <class /*E*/>
    static void finish_enum(auto&) {}
 
    // --- namespace / module binding -----------------------------------------

    static session open_module(module_type&) { return {}; }

    static void set_module_doc(module_type&, const char*) {}

    template <auto Fns, class Style = ::welder::naming::none>
    static void add_function(module_type& m, const char* name = nullptr) {
        lb::Namespace ns{_open_namespace(m)};
        _add_function<Fns>(
            ns,
            ::welder::name_of_or<Fns[0], language, Style,
                                 ::welder::ent_kind::function>(name),
            std::make_index_sequence<Fns.size()>{});
    }

    template <std::meta::info Var, class Style = ::welder::naming::none>
    static void add_variable(module_type& m, session& /*s*/,
                             const char* name = nullptr) {
        const char* key{::welder::name_of_or<Var, language, Style,
                                             ::welder::ent_kind::variable>(name)};
        lb::Namespace ns{_open_namespace(m)};
        if constexpr (std::meta::is_const_type(std::meta::type_of(Var))) {
            ns.addVariable(key, [:Var:]); // immutable: a value snapshot at load time
        } else {
            using VT = typename [:std::meta::type_of(Var):];
            ns.addProperty(
                key, +[]() -> VT { return [:Var:]; }, +[](VT v) { [:Var:] = v; });
        }
    }

    static module_type add_submodule(module_type& m, const char* name) {
        _open_namespace(m).beginNamespace(name); // create, then unwind
        module_type sub{m};
        sub.path.emplace_back(name);
        return sub;
    }

    static void close_module(module_type&, session&) {}
};
 
static_assert(::welder::rod<rod>,
              "welder::rods::luabridge::rod must satisfy welder::rod");
 
} // namespace welder::rods::luabridge