Extending a derived class in Lua - other derived class instances share the method even if they shouldn't

[henrar]

Hey all, I'm new to Lua/Luabridge and I've been trying to call an instance method from C++. The classes were registered with luabridge::extensibleClass flag and it seems that classes that share the same base all have the same method defined even if only one derived class should have a given Lua method.

Am I doing something wrong or is that scenario unsupported?

My code's below (tested in Visual Studio 2022, C++17, Lua 5.4.6):

extern "C"
{
#include <lualib.h>
#include <lauxlib.h>
#include <lua.h>
}

#include "LuaBridge.h"
#include <string>
#include <iostream>
#include <cassert>

extern "C"
{
    // function to redirect Lua print() to Visual Studio Output window
    static int testPrint(lua_State* L)
    {
        const int nargs = lua_gettop(L);
        std::string t;
        for (int i = 1; i <= nargs; i++) 
        {
            t += lua_tostring(L, i);
            t += " ";
        }
		std::cout << t << "\n";
        return 0;
    }

    // function to open custom libraries
    static void openlibs(lua_State* L) 
    {
        static const luaL_Reg mylibs[] = 
        {
            {LUA_GNAME, luaopen_base},
            {LUA_LOADLIBNAME, luaopen_package},
            {LUA_COLIBNAME, luaopen_coroutine},
            {LUA_TABLIBNAME, luaopen_table},
            {LUA_IOLIBNAME, luaopen_io},
            {LUA_OSLIBNAME, luaopen_os},
            {LUA_STRLIBNAME, luaopen_string},
            {LUA_MATHLIBNAME, luaopen_math},
            {LUA_UTF8LIBNAME, luaopen_utf8},
            {LUA_DBLIBNAME, luaopen_debug},
            #if defined(LUA_COMPAT_BITLIB)
            {LUA_BITLIBNAME, luaopen_bit32},
            #endif
            {nullptr, nullptr}
        };

        const luaL_Reg* lib = mylibs;
        for (; lib->func != nullptr; lib++)
        {
            luaL_requiref(L, lib->name, lib->func, 1);
            lua_pop(L, 1);  /* remove lib */
        }
    }
}

 bool runLua(const std::string& script, lua_State* mainState)
{
    auto stateToUse = mainState;

    lua_settop(stateToUse, 0);

    if (luaL_loadstring(stateToUse, script.c_str()) != LUABRIDGE_LUA_OK)
    {
        [[maybe_unused]] auto errorString = lua_tostring(stateToUse, -1);

#if LUABRIDGE_HAS_EXCEPTIONS
        throw std::runtime_error(errorString ? errorString : "Unknown lua compilation error");
#else
#if LUABRIDGE_TESTS_PRINT_ERRORS
        std::cerr << "===== Lua Compile Error =====\n";
        std::cerr << errorString ? errorString : "Unknown lua compilation error" << "\n";
#endif // LUABRIDGE_TESTS_PRINT_ERRORS
        return false;
#endif // LUABRIDGE_HAS_EXCEPTIONS
    }

    if (lua_pcall(stateToUse, 0, 0, -2) != LUABRIDGE_LUA_OK)
    {
        [[maybe_unused]] auto errorString = lua_tostring(stateToUse, -1);

#if LUABRIDGE_HAS_EXCEPTIONS
        std::cerr << "===== Lua Call Error =====\n";
        std::cerr << (errorString ? errorString : "Unknown lua runtime error") << "\n";
        throw std::runtime_error(errorString ? errorString : "Unknown lua runtime error");
#else
#if LUABRIDGE_TESTS_PRINT_ERRORS
        std::cerr << "===== Lua Call Error =====\n";
        std::cerr << (errorString ? errorString : "Unknown lua runtime error") << "\n";
#endif // LUABRIDGE_TESTS_PRINT_ERRORS
        return false;
#endif // LUABRIDGE_HAS_EXCEPTIONS
    }

    return true;
}

class GameObject
{
public:
	explicit GameObject(const std::string& n) : name(n)
	{
		
	}

	static void RegisterForLua(lua_State* L);

    const std::string& GetName() const
	{
	    return name;
    }

    static std::string GetStaticName()
    {
	    return "GameObject";
    }

protected:
    std::string name;
};

class Player : public GameObject
{
public:
	Player() : GameObject("Player")
	{
		
	}

	static void RegisterForLua(lua_State* L);
};

class Enemy : public GameObject
{
public:
	Enemy() : GameObject("Enemy")
	{
		
	}

	static void RegisterForLua(lua_State* L);
};

class Unrelated
{
public:
	Unrelated() : name("Unrelated")
	{
		
	}

    const std::string& GetName() const
	{
	    return name;
    }

	static void RegisterForLua(lua_State* L);

protected:
    std::string name;
};

void GameObject::RegisterForLua(lua_State* L)
{
	luabridge::getGlobalNamespace(L)
	  .beginNamespace("test")
	    .beginClass<GameObject>("GameObject", luabridge::extensibleClass)
	      .addConstructor<void(*) (const std::string&)>()
	      .addFunction("GetName", &GameObject::GetName)
	      .addStaticFunction("StaticGetName", &GameObject::GetStaticName)
	    .endClass()
	  .endNamespace();
}

void Player::RegisterForLua(lua_State* L)
{
	luabridge::getGlobalNamespace(L)
	  .beginNamespace("test")
	    .deriveClass<Player, GameObject>("Player", luabridge::extensibleClass)
			.addConstructor<void (*)()>()
	    .endClass()
	  .endNamespace();
}

void Enemy::RegisterForLua(lua_State* L)
{
	luabridge::getGlobalNamespace(L)
	  .beginNamespace("test")
	    .deriveClass<Enemy, GameObject>("Enemy", luabridge::extensibleClass)
			.addConstructor<void (*) ()>()
	    .endClass()
	  .endNamespace();
}

void Unrelated::RegisterForLua(lua_State* L)
{
	luabridge::getGlobalNamespace(L)
	  .beginNamespace("test")
	    .beginClass<Unrelated>("Unrelated")
		  .addConstructor<void (*) ()>()
	      .addFunction("GetName", &Unrelated::GetName)
	    .endClass()
	  .endNamespace();
}

void DefineCustomFunctions(lua_State* mainState)
{
    lua_pushcfunction(mainState, testPrint);
    lua_setglobal(mainState, "print");
}

lua_State* InitializeLua()
{
    lua_State* mainState = luaL_newstate();
    assert(mainState != nullptr);
    
    openlibs(mainState);
    
    luabridge::registerMainThread(mainState);
    
    DefineCustomFunctions(mainState);

    lua_newtable(mainState);

	return mainState;
}


void ExecuteFunction(lua_State* mainState, const std::string& instanceName, const std::string& funcName)
{
	luabridge::LuaRef instance = luabridge::getGlobal(mainState, instanceName.c_str());
	if (instance.isValid())
	{
		luabridge::LuaRef method = instance[funcName.c_str()];
		if (method.isFunction())
		{
			auto result = method(instance);
            if (!result.wasOk())
            {
	            std::cerr << result.errorMessage().c_str() << "\n";
            }
            assert(result.wasOk());
		}
	}
}

int main()
{
    lua_State* mainState = InitializeLua();
    std::cout << "Lua initialized" << "\n";

    GameObject::RegisterForLua(mainState);
    Player::RegisterForLua(mainState);
    Enemy::RegisterForLua(mainState);
    Unrelated::RegisterForLua(mainState);

    const std::string luaScript = R"(
local test = test

function globalTest()
	print("GlobalTest")
end

function test.Player:printName()
    local name = self:GetName()
    print("Hello from lua: ".. name)
end

function test.Player:printTest()
    print("test")
end
)";

    runLua(luaScript, mainState);
    //luaL_dostring(mainState, luaScript.c_str());

    Unrelated unrelated;
    luabridge::setGlobal(mainState, &unrelated, "unrelated_instance");
    std::cout << "Created class: " << unrelated.GetName() << "\n";

    Player player;
    luabridge::setGlobal(mainState, &player, "player_instance");
    std::cout << "Created class: " << player.GetName() << "\n";

    Enemy enemy;
    luabridge::setGlobal(mainState, &enemy, "enemy_instance");
    std::cout << "Created class: " << enemy.GetName() << "\n";


	{
		luabridge::LuaRef function = luabridge::getGlobal(mainState, "globalTest");         // this prints
    	function();
	}

    ExecuteFunction(mainState, "enemy_instance", "printTest");          // this prints
    ExecuteFunction(mainState, "player_instance", "printTest");         // this also prints
    ExecuteFunction(mainState, "unrelated_instance", "printTest");      // this does not print

	ExecuteFunction(mainState, "enemy_instance", "printName");          // prints
    ExecuteFunction(mainState, "player_instance", "printName");         // prints
 ExecuteFunction(mainState, "unrelated_instance", "printName");      // this does not print

    lua_close(mainState);
	std::cout << "Lua closed" << std::endl;

    return 0;
}

[kunitoki]

This is a known issue #167 and should be fixed. At the moment i'm a bit busy but will eventually look at it.