Please help set up conversions

[3lyrion]

namespace luabridge
{

template <>
struct StackConversion<mr::Vector2u>
{
    static constexpr bool enabled = true;
};

template <>
struct StackConverter<mr::Vector2f, mr::Vector2u>
{
    static mr::Vector2f convert(mr::Vector2u const& v)
    {
        return mr::Vector2f(v);
    }
};

template <>
struct StackConversion<mr::Vector2i>
{
    static constexpr bool enabled = true;
};

template <>
struct StackConverter<mr::Vector2f, mr::Vector2i>
{
    static mr::Vector2f convert(mr::Vector2i const& v)
    {
        return mr::Vector2f(v);
    }
};

template <>
struct StackConversion<mr::Vector2f>
{
    static constexpr bool enabled = true;
};

template <>
struct StackConverter<mr::Vector2u, mr::Vector2f>
{
    static mr::Vector2u convert(mr::Vector2f const& v)
    {
        return mr::Vector2u(v);
    }
};

template <>
struct StackConverter<mr::Vector2i, mr::Vector2f>
{
    static mr::Vector2i convert(mr::Vector2f const& v)
    {
        return mr::Vector2i(v);
    }
};

} // namespace luabridge

...

getGlobalNamespace(L).beginClass<Vector2f>("Vec2")
    .addPropertyReadWrite("x", &Vector2f::x)
    .addPropertyReadWrite("y", &Vector2f::y)
    .addConverter<Vector2i>()
    .addConverter<Vector2u>()
    .addConstructor<Vector2f(), Vector2f(float, float)>()
.endClass()
.beginClass<Texture>("Texture")
    .setProperty("size", &Texture::getSize) // Vector2u
.endClass();

local texture = sprite.texture
local size = texture.size -- <-- CRASH

In sol2, these conversions looked like this:

namespace sol
{

namespace stack 
{

    template <>
    struct unqualified_pusher<mr::Vector2i>
    {
        static int push(lua_State* L, mr::Vector2i value)
        {
            mr::Vector2f converted(value);
            return stack::push(L, converted);
        }
    };

    template <>
    struct unqualified_pusher<mr::Vector2u>
    {
        static int push(lua_State* L, mr::Vector2u value)
        {
            mr::Vector2f converted(value);
            return stack::push(L, converted);
        }
    };

    template <>
    struct unqualified_getter<mr::Vector2i>
    {
        static mr::Vector2i get(lua_State* L, int index, record& tracking)
        {
            mr::Vector2f v = stack::get<mr::Vector2f>(L, index, tracking);
            return mr::Vector2i(v);
        }
    };

    template <>
    struct unqualified_getter<mr::Vector2u>
    {
        static mr::Vector2u get(lua_State* L, int index, record& tracking)
        {
            mr::Vector2f v = stack::get<mr::Vector2f>(L, index, tracking);
            return mr::Vector2u(v);
        }
    };

    template <>
    struct unqualified_checker<mr::Vector2i, sol::type::userdata> :
        unqualified_checker<mr::Vector2f, sol::type::userdata> {};
        
    template <>
    struct unqualified_checker<mr::Vector2u, sol::type::userdata> :
        unqualified_checker<mr::Vector2f, sol::type::userdata> {};

} // namespace stack

} // namespace sol

[Mellnik]

Codex says you can fix it like this:

`addConverter` only affects conversion when reading Lua userdata as another C++ type. It does not convert C++ return values before pushing them to Lua.

Since `Texture::getSize()` returns `Vector2u`, add a `Stack<Vector2u>` specialization that forwards `push/get/isInstance` through `Stack<Vector2f>`. Do the same for `Vector2i`.

Codex also says to the maintainer:

There is also a stack-integrity issue in `UserdataValue<T>::place()`: it allocates userdata before checking whether `T` is registered. On failure, it destroys the wrapper but leaves the userdata on the Lua stack.

The registration lookup should happen before `lua_newuserdata`, with a regression test asserting that pushing an unregistered type leaves the stack unchanged.

[3lyrion]

@kunitoki It would be nice to add this point to the docs