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);
        }
        if (Aggregate) {
            std::vector<std::meta::info> args;
            for (auto fld : ::welder::detail::aggregate_fields<T>())
                args.push_back(std::meta::type_of(fld));
            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>
    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>()};
        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 (std::meta::is_const_type(std::meta::type_of(Mem)))
                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 (std::meta::is_const_type(std::meta::type_of(Mem)))
                cls.addProperty(name, mp);      // read-only (const member)
            else
                cls.addProperty(name, mp, mp);  // read/write
        }
    }

    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 <auto Fns>
    static void add_operator(auto& h) {
        using T = _class_type<decltype(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)};
                _add_function<Fns>(cls, slot, std::make_index_sequence<Fns.size()>{});
            }
        }
    }
 
    // --- 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