Implement to/from dict helpers for PropertyInfo/MethodInfo

(cherry picked from commit 2a041b5240)

include/godot_cpp/core/property_info.hpp

@@ -68,6 +68,63 @@ struct PropertyInfo {
 
 	PropertyInfo(GDExtensionVariantType p_type, const StringName &p_name, PropertyHint p_hint = PROPERTY_HINT_NONE, const String &p_hint_string = "", uint32_t p_usage = PROPERTY_USAGE_DEFAULT, const StringName &p_class_name = "") :
 			PropertyInfo((Variant::Type)p_type, p_name, p_hint, p_hint_string, p_usage, p_class_name) {}
+
+	PropertyInfo(const GDExtensionPropertyInfo *p_info) :
+			PropertyInfo(p_info->type, *reinterpret_cast<StringName *>(p_info->name), (PropertyHint)p_info->hint, *reinterpret_cast<String *>(p_info->hint_string), p_info->usage, *reinterpret_cast<StringName *>(p_info->class_name)) {}
+
+	operator Dictionary() const {
+		Dictionary dict;
+		dict["name"] = name;
+		dict["class_name"] = class_name;
+		dict["type"] = type;
+		dict["hint"] = hint;
+		dict["hint_string"] = hint_string;
+		dict["usage"] = usage;
+		return dict;
+	}
+
+	static PropertyInfo from_dict(const Dictionary &p_dict) {
+		PropertyInfo pi;
+		if (p_dict.has("type")) {
+			pi.type = Variant::Type(int(p_dict["type"]));
+		}
+		if (p_dict.has("name")) {
+			pi.name = p_dict["name"];
+		}
+		if (p_dict.has("class_name")) {
+			pi.class_name = p_dict["class_name"];
+		}
+		if (p_dict.has("hint")) {
+			pi.hint = PropertyHint(int(p_dict["hint"]));
+		}
+		if (p_dict.has("hint_string")) {
+			pi.hint_string = p_dict["hint_string"];
+		}
+		if (p_dict.has("usage")) {
+			pi.usage = p_dict["usage"];
+		}
+		return pi;
+	}
+
+	void _update(GDExtensionPropertyInfo *p_info) {
+		p_info->type = (GDExtensionVariantType)type;
+		*(reinterpret_cast<StringName *>(p_info->name)) = name;
+		p_info->hint = hint;
+		*(reinterpret_cast<String *>(p_info->hint_string)) = hint_string;
+		p_info->usage = usage;
+		*(reinterpret_cast<StringName *>(p_info->class_name)) = class_name;
+	}
+
+	GDExtensionPropertyInfo _to_gdextension() const {
+		return {
+			(GDExtensionVariantType)type,
+			name._native_ptr(),
+			class_name._native_ptr(),
+			hint,
+			hint_string._native_ptr(),
+			usage,
+		};
+	}
 };
 
 } // namespace godot

src/core/object.cpp

@@ -60,8 +60,66 @@ Object *get_object_instance_binding(GodotObject *p_engine_object) {
 	return reinterpret_cast<Object *>(gdextension_interface_object_get_instance_binding(p_engine_object, token, binding_callbacks));
 }
 
+TypedArray<Dictionary> convert_property_list(const std::vector<PropertyInfo> &p_list) {
+	TypedArray<Dictionary> va;
+	for (const PropertyInfo &pi : p_list) {
+		va.push_back(Dictionary(pi));
+	}
+	return va;
+}
+
 } // namespace internal
 
+MethodInfo::operator Dictionary() const {
+	Dictionary dict;
+	dict["name"] = name;
+	dict["args"] = internal::convert_property_list(arguments);
+	Array da;
+	for (int i = 0; i < default_arguments.size(); i++) {
+		da.push_back(default_arguments[i]);
+	}
+	dict["default_args"] = da;
+	dict["flags"] = flags;
+	dict["id"] = id;
+	Dictionary r = return_val;
+	dict["return"] = r;
+	return dict;
+}
+
+MethodInfo MethodInfo::from_dict(const Dictionary &p_dict) {
+	MethodInfo mi;
+
+	if (p_dict.has("name")) {
+		mi.name = p_dict["name"];
+	}
+	Array args;
+	if (p_dict.has("args")) {
+		args = p_dict["args"];
+	}
+
+	for (int i = 0; i < args.size(); i++) {
+		Dictionary d = args[i];
+		mi.arguments.push_back(PropertyInfo::from_dict(d));
+	}
+	Array defargs;
+	if (p_dict.has("default_args")) {
+		defargs = p_dict["default_args"];
+	}
+	for (int i = 0; i < defargs.size(); i++) {
+		mi.default_arguments.push_back(defargs[i]);
+	}
+
+	if (p_dict.has("return")) {
+		mi.return_val = PropertyInfo::from_dict(p_dict["return"]);
+	}
+
+	if (p_dict.has("flags")) {
+		mi.flags = p_dict["flags"];
+	}
+
+	return mi;
+}
+
 MethodInfo::MethodInfo() :
 		flags(GDEXTENSION_METHOD_FLAG_NORMAL) {}