Add LuaScriptInstance struct (#5)

Now script instances are a struct with a table for storing data. This
makes it possible to always call setter functions on __newindex,
regardless of if there already was a value in the table.
The methods `rawget` and `rawset` were added to index the table
directly, without calling getters/setters or indexing the owner Object.

Author: gilzoide

Makefile

@@ -93,6 +93,7 @@ LUA_INIT_SCRIPT_SRC = \
 	src/godot_pool_vector3_array.lua \
 	src/godot_pool_color_array.lua \
 	src/pluginscript_script.lua \
+	src/pluginscript_instance.lua \
 	src/pluginscript_class_metadata.lua \
 	src/pluginscript_callbacks.lua \
 	src/late_globals.lua \

src/godot_class.lua

@@ -224,79 +224,3 @@ local MethodBindByName = {
 	end,
 }
 
-
---- Script instance metatable, the Lua side of a Lua script instance.
--- These are created when a PluginScript is instanced and are only directly
--- accessible in the script's functions as the `self` parameter.
--- @type ScriptInstance
-local instance_methods = {
-	fillvariant = function(var, self)
-		api.godot_variant_new_object(var, rawget(self, '__owner'))
-	end,
-	--- Forwards a call to `__owner` using `Object:pcall`.
-	-- @function pcall
-	-- @param method  Method name
-	-- @param ...
-	-- @treturn[1] bool `true` if method exists
-	-- @return[1] Method result
-	-- @treturn[2] bool `false` if method does not exist
-	-- @see Object.pcall
-	pcall = function(self, ...)
-		return rawget(self, '__owner'):pcall(...)
-	end,
-	--- Forwards a call to `__owner` using `Object:call`.
-	-- @function call
-	-- @param method  Method name
-	-- @param ...
-	-- @return[1] Method result
-	-- @treturn[2] nil  If method does not exist or errors
-	-- @see Object.call
-	call = function(self, ...)
-		return rawget(self, '__owner'):call(...)
-	end,
-}
-local ScriptInstance = {
-	--- `Object` that this script instance is attached to.
-	-- This is the Godot side of the instance.
-	-- @field __owner
-	
-	--- Lua script table, the one returned by the Lua script when loading it as a PluginScript.
-	-- Note that calling `Object:get_script` will return an `Object` rather
-	-- than this table.
-	-- @field __script
-	
-	--- Try indexing `__script`, then `__owner`.
-	-- @function __index
-	-- @param key
-	-- @return
-	-- @see Object.__index
-	__index = function(self, key)
-		local script_value = instance_methods[key] or rawget(self, '__script')[key]
-		if script_value ~= nil then return script_value end
-		return rawget(self, '__owner')[key]
-	end,
-	--- Calls `Object:set` if `key` is the name of a property known to base class, `rawset` otherwise.
-	-- @function __newindex
-	-- @param key
-	-- @param value
-	__newindex = function(self, key, value)
-		if self:get_class_wrapper():has_property(key) then
-			Object_set(rawget(self, '__owner'), key, value)
-		else
-			rawset(self, key, value)
-		end
-	end,
-	--- Returns a Lua string representation of `__owner`, as per `Object:to_string`.
-	-- @function __tostring
-	-- @treturn string
-	__tostring = function(self)
-		return tostring(rawget(self, '__owner'))
-	end,
-	--- Concatenates values.
-	-- @function __concat
-	-- @param a  First value, stringified with `GD.str`
-	-- @param b  First value, stringified with `GD.str`
-	-- @treturn String
-	__concat = concat_gdvalues,
-}
-

src/language_gdnative.c

@@ -202,10 +202,10 @@ static godot_pluginscript_instance_data *lps_instance_init(godot_pluginscript_sc
 	lps_push_callback(lps_L, "instance_init");
 	lua_pushlightuserdata(lps_L, (void *) data);
 	lua_pushlightuserdata(lps_L, (void *) owner);
-	if (lua_pcall(lps_L, 2, 0, 0) != LUA_OK) {
-		return NULL;
-	}
-	return owner;
+	void *result = NULL;
+	lua_pushlightuserdata(lps_L, (void *) &result);
+	lua_pcall(lps_L, 3, 0, 0);
+	return result;
 }
 
 static void lps_instance_finish(godot_pluginscript_instance_data *data) {

src/lua_object_helper.lua

@@ -27,29 +27,28 @@
 -- and are only unreferenced when `LuaObject_destroy` is called.
 -- Thus this struct must used with care.
 --
--- This is used internally for having `LuaScriptWrapper` be a struct that
--- reference tables.
+-- This is used internally for having `LuaScriptWrapper` and `LuaScriptInstance`
+-- be structs that reference tables.
 --
 --     typedef struct {
 --       void *address;
 --     } lps_lua_object;
 --
 -- @module LuaObject
--- @local
 
 ffi_cdef[[
 typedef struct {
 	void *address;
 } lps_lua_object;
 ]]
 
+local lps_lua_objects = {}
+
 --- Helper function to convert a `void *` to a table index.
 local function pointer_to_index(ptr)
 	return tonumber(ffi_cast('uintptr_t', ptr))
 end
 
-local lps_lua_objects = {}
-
 --- Gets the Lua object referenced by a LuaObject
 local function LuaObject_get(self)
 	return lps_lua_objects[pointer_to_index(self.address)]

src/pluginscript_callbacks.lua

@@ -84,7 +84,9 @@ pluginscript_callbacks.wrap_callback = wrap_callback
 -- void (*)(const godot_string *name, const godot_variant *value);
 pluginscript_callbacks.language_add_global_constant = wrap_callback(function(name, value)
 	name = tostring(ffi_cast('godot_string *', name))
+
 	lps_callstack:push('add_global', string_quote(name))
+
 	_G[name] = ffi_cast('godot_variant *', value):unbox()
 end)
 
@@ -96,6 +98,7 @@ pluginscript_callbacks.script_init = wrap_callback(function(manifest, path, sour
 	err = ffi_cast('godot_error *', err)
 
 	lps_callstack:push('script_load', '@', string_quote(path))
+
 	local script, err_message = loadstring(source, path)
 	if not script then
 		local line, msg = string_match(err_message, ERROR_LINE_MESSAGE_PATT)
@@ -115,6 +118,7 @@ pluginscript_callbacks.script_init = wrap_callback(function(manifest, path, sour
 		return
 	end
 
+	local base_class
 	local known_properties = {}
 	for k, v in pairs(script) do
 		if k == 'class_name' then
@@ -130,7 +134,8 @@ pluginscript_callbacks.script_init = wrap_callback(function(manifest, path, sour
 				)
 				return
 			end
-			manifest.base = ffi_gc(StringName(cls.class_name), nil)
+			base_class = cls.class_name
+			manifest.base = ffi_gc(StringName(base_class), nil)
 		elseif type(v) == 'function' then
 			local method = method_to_dictionary(v)
 			method.name = String(k)
@@ -149,63 +154,70 @@ pluginscript_callbacks.script_init = wrap_callback(function(manifest, path, sour
 			manifest.properties:append(prop_dict)
 		end
 	end
-	manifest.data = LuaScriptWrapper_new(path, known_properties, script)
+	manifest.data = LuaScriptWrapper_new(path, base_class, known_properties, script)
 	err[0] = Error.OK
 end)
 
 -- void (*)(godot_pluginscript_script_data *data);
 pluginscript_callbacks.script_finish = wrap_callback(function(data)
 	local script = ffi_cast('lps_lua_script *', data)
+
 	lps_callstack:push('script_finish')
+
 	LuaScriptWrapper_destroy(script)
 end)
 
--- void (*)(godot_pluginscript_script_data *data, godot_object *owner);
-pluginscript_callbacks.instance_init = wrap_callback(function(data, owner)
+-- void (*)(godot_pluginscript_script_data *data, godot_object *owner, void **result);
+pluginscript_callbacks.instance_init = wrap_callback(function(data, owner, result)
 	local script = ffi_cast('lps_lua_script *', data)
 	owner = ffi_cast('godot_object *', owner)
+	result = ffi_cast('lps_script_instance **', result)
 
 	lps_callstack:push('_init', '@', string_quote(script.__path))
-	local instance = setmetatable({
-		__owner = owner,
-		__script = script,
-	}, ScriptInstance)
+
+	local instance = LuaScriptInstance_new(owner, script)
 	for name, prop in pairs(script.__properties) do
 		if not prop.getter then
 			local property_initializer = property_initializer_for_type[prop.type]
 			if property_initializer then
-				rawset(instance, name, property_initializer(prop.default_value))
+				instance:rawset(name, property_initializer(prop.default_value))
 			end
 		end
 	end
 	local _init = script._init
 	if _init then
 		_init(instance)
 	end
+	result[0] = instance
 	set_lua_instance(owner, instance)
 end)
 
 -- void (*)(godot_pluginscript_instance_data *data);
 pluginscript_callbacks.instance_finish = wrap_callback(function(data)
+	local self = ffi_cast('lps_script_instance *', data)
+	
 	lps_callstack:push('finish')
-	set_lua_instance(data, nil)
+
+	set_lua_instance(self.__owner, nil)
+	LuaScriptInstance_destroy(self)
 end)
 
 -- godot_bool (*)(godot_pluginscript_instance_data *data, const godot_string *name, const godot_variant *value);
 pluginscript_callbacks.instance_set_prop = wrap_callback(function(data, name, value)
-	local self = get_lua_instance(data)
+	local self = ffi_cast('lps_script_instance *', data)
 	name = tostring(ffi_cast('godot_string *', name))
 	value = ffi_cast('godot_variant *', value)
 
 	local script = self.__script
 	lps_callstack:push('set', string_quote(name), '@', string_quote(script.__path))
+
 	local prop = script.__properties[name]
 	if prop then
 		local setter = prop.setter
 		if setter then
 			setter(self, value:unbox())
 		else
-			rawset(self, name, value:unbox())
+			self:rawset(name, value:unbox())
 		end
 		return true
 	else
@@ -219,20 +231,21 @@ end, false)
 
 -- godot_bool (*)(godot_pluginscript_instance_data *data, const godot_string *name, godot_variant *ret);
 pluginscript_callbacks.instance_get_prop = wrap_callback(function(data, name, ret)
-	local self = get_lua_instance(data)
+	local self = ffi_cast('lps_script_instance *', data)
 	name = tostring(ffi_cast('godot_string *', name))
 	ret = ffi_cast('godot_variant *', ret)
 
 	local script = self.__script
 	lps_callstack:push('get', string_quote(name), '@', string_quote(script.__path))
+
 	local prop = script.__properties[name]
 	if prop then
 		local getter, value = prop.getter, nil
 		if getter then
 			value = getter(self)
 		else
 			-- Avoid infinite recursion from `self[name]`, since `__index` may call `Object:get`
-			value = rawget(self, name)
+			value = self:rawget(name)
 			if value == nil then
 				value = prop.default_value
 			end
@@ -254,14 +267,15 @@ end, false)
 
 -- void (*)(godot_pluginscript_instance_data *data, const godot_string_name *method, const godot_variant **args, int argcount, godot_variant *ret, godot_variant_call_error *error);
 pluginscript_callbacks.instance_call_method = wrap_callback(function(data, name, args, argcount, ret, err)
-	local self = get_lua_instance(data)
+	local self = ffi_cast('lps_script_instance *', data)
 	name = tostring(ffi_cast('godot_string_name *', name))
 	args = ffi_cast('godot_variant **', args)
 	ret = ffi_cast('godot_variant *', ret)
 	err = ffi_cast('godot_variant_call_error *', err)
 
 	local script = self.__script
 	lps_callstack:push('call', name, '@', script.__path)
+
 	local method = script[name]
 	if method ~= nil then
 		local args_table = {}
@@ -284,9 +298,11 @@ end)
 
 -- void (*)(godot_pluginscript_instance_data *data, int notification);
 pluginscript_callbacks.instance_notification = wrap_callback(function(data, what)
-	local self = get_lua_instance(data)
+	local self = ffi_cast('lps_script_instance *', data)
+	
 	local script = self.__script
 	lps_callstack:push('_notification', '@', script.__path)
+
 	local _notification = script._notification
 	if _notification then
 		return _notification(self, what)