type_map.hpp

Go to the documentation of this file.

#pragma once
#include <cstddef>
#include <meta>
#include <string>
#include <string_view>
#include <type_traits>
#include <vector>
 
#include <welder/bind_traits.hpp> // is_unary_operator
#include <welder/bindable.hpp>    // the STL-wrapper template names + reflect layer

 
namespace welder::inline v0::rods::luacats {
 
// --- small text helpers -----------------------------------------------------

inline void emit_doc_comment(std::string& out, const char* text) {
    if (!text || !*text)
        return;
    out += "--- ";
    for (const char* c{text}; *c; ++c) {
        out += *c;
        if (*c == '\n' && c[1] != '\0')
            out += "--- ";
    }
    out += '\n';
}

inline std::string one_line(const char* text) {
    std::string out{};
    if (!text)
        return out;
    for (const char* c{text}; *c; ++c)
        out += (*c == '\n') ? ' ' : *c;
    return out;
}
 
// --- the C++ -> LuaCATS type map --------------------------------------------

consteval std::string qualified_name(std::meta::info ent) {
    std::vector<std::string> parts{};
    if (std::meta::has_identifier(ent))
        parts.emplace_back(std::meta::identifier_of(ent));
    std::meta::info p{std::meta::parent_of(ent)};
    while (p != ^^:: &&
           (std::meta::is_namespace(p) ||
            (std::meta::is_type(p) && std::meta::is_class_type(p)))) {
        if (std::meta::has_identifier(p))
            parts.emplace_back(std::meta::identifier_of(p));
        p = std::meta::parent_of(p);
    }
    std::string out{};
    for (auto it{parts.rbegin()}; it != parts.rend(); ++it) {
        if (!out.empty())
            out += '.';
        out += *it;
    }
    return out;
}

consteval bool type_trait(std::meta::info trait_var, std::meta::info t) {
    return std::meta::extract<bool>(std::meta::substitute(trait_var, {t}));
}

consteval bool is_wrapper(std::meta::info type, std::meta::info& tmpl_out) {
    if (!std::meta::has_template_arguments(type))
        return false;
    tmpl_out = std::meta::template_of(type);
    return true;
}

consteval std::string lua_type_string(std::meta::info type) {
    namespace m = std::meta;
    const m::info w{m::dealias(m::substitute(^^std::remove_cvref_t, {type}))};
 
    // String-like (handled before the arithmetic/class buckets).
    if (w == m::dealias(^^std::string) || w == m::dealias(^^std::string_view))
        return "string";
    if (type_trait(^^std::is_pointer_v, w)) {
        const m::info pointee{m::dealias(m::substitute(
            ^^std::remove_cv_t, {m::substitute(^^std::remove_pointer_t, {w})}))};
        if (pointee == ^^char)
            return "string";
        return lua_type_string(pointee); // a pointer to a value type = that type
    }
 
    // Element-wise STL wrappers.
    m::info tmpl{};
    if (is_wrapper(w, tmpl)) {
        const auto args{m::template_arguments_of(w)};
        auto elem = [&](std::size_t i) { return lua_type_string(args[i]); };
        if (tmpl == ^^std::vector || tmpl == ^^std::list || tmpl == ^^std::deque ||
            tmpl == ^^std::set || tmpl == ^^std::multiset ||
            tmpl == ^^std::unordered_set || tmpl == ^^std::unordered_multiset ||
            tmpl == ^^std::array)
            return elem(0) + "[]";
        if (tmpl == ^^std::map || tmpl == ^^std::multimap ||
            tmpl == ^^std::unordered_map || tmpl == ^^std::unordered_multimap)
            return "table<" + elem(0) + ", " + elem(1) + ">";
        if (tmpl == ^^std::optional)
            return elem(0) + "?";
        if (tmpl == ^^std::shared_ptr || tmpl == ^^std::unique_ptr)
            return elem(0);
        if (tmpl == ^^std::pair)
            return "{ [1]: " + elem(0) + ", [2]: " + elem(1) + " }";
        if (tmpl == ^^std::variant) {
            std::string out{};
            for (std::size_t i{0}; i < args.size(); ++i)
                out += (i ? "|" : "") + lua_type_string(args[i]);
            return out;
        }
        // std::tuple and any other specialization fall through to the class map.
    }
 
    if (w == ^^bool)
        return "boolean";
    if (type_trait(^^std::is_integral_v, w))
        return "integer";
    if (type_trait(^^std::is_floating_point_v, w))
        return "number";
    if (m::is_enum_type(w) || m::is_class_type(w))
        return qualified_name(w);
    return "any";
}

consteval const char* lua_type(std::meta::info type) {
    return std::define_static_string(lua_type_string(type));
}

template <class U>
inline constexpr bool is_native_lua =
    std::is_arithmetic_v<U> ||
    std::is_same_v<std::remove_cv_t<U>, std::string> ||
    std::is_same_v<std::remove_cv_t<U>, std::string_view> ||
    std::is_same_v<std::remove_cv_t<std::remove_pointer_t<std::remove_cvref_t<U>>>,
                   char>;
 
// --- the C++ -> LuaCATS operator map ----------------------------------------

consteval const char* operator_luacats(std::meta::info f) {
    using std::meta::operators;
    const bool unary{::welder::detail::is_unary_operator(f)};
    switch (std::meta::operator_of(f)) {
        case operators::op_plus:    return unary ? nullptr : "add";
        case operators::op_minus:   return unary ? "unm" : "sub";
        case operators::op_star:    return unary ? nullptr : "mul";
        case operators::op_slash:   return "div";
        case operators::op_percent: return "mod";
        case operators::op_parentheses: return "call";
        // Bitwise (Lua 5.3+). C++ operator^ is XOR (→ bxor), NOT power (Lua ^).
        case operators::op_caret:   return "bxor";
        case operators::op_tilde:   return unary ? "bnot" : nullptr;
        case operators::op_ampersand: return unary ? nullptr : "band"; // unary & = address-of
        case operators::op_pipe:            return "bor";
        case operators::op_less_less:       return "shl";
        case operators::op_greater_greater: return "shr";
        default: return nullptr; // ==/</<=/[], !=/>/>=: not a LuaCATS @operator
    }
}
 
} // namespace welder::rods::luacats