Add VariantType support for exported fields.

Also some PR comment fixes from this and the previous commit.

Author: mhoff12358

godot-macros/src/derive_godot_class.rs

@@ -228,46 +228,45 @@ struct ExportedField {
     field: Field,
     getter: String,
     setter: String,
+    variant_type: String,
 }
 
 impl ExportedField {
     pub fn new_from_kv(
         field: Field,
         attr: &Attribute,
         mut map: KvMap,
-    ) -> Result<ExportedField, venial::Error> {
-        let export_getter: String;
-        let export_setter: String;
-        if let Some(getter) = map.remove("getter") {
-            if let KvValue::Lit(getter) = getter {
-                export_getter = getter;
-            } else {
-                return Err(bail_error(
-                    "#[property] attribute with a non-literal getter",
-                    attr,
-                ));
-            }
-        } else {
-            return Err(bail_error("#[property] attribute without a getter", attr));
-        }
-        if let Some(setter) = map.remove("setter") {
-            if let KvValue::Lit(setter) = setter {
-                export_setter = setter;
+    ) -> ParseResult<ExportedField> {
+        let getter = Self::require_key_value(&mut map, "getter", attr)?;
+        let setter = Self::require_key_value(&mut map, "setter", attr)?;
+        let variant_type = Self::require_key_value(&mut map, "variant_type", attr)?;
+
+        ensure_kv_empty(map, attr.__span())?;
+
+        return Ok(ExportedField {
+            field,
+            getter,
+            setter,
+            variant_type,
+        });
+    }
+
+    fn require_key_value(map: &mut KvMap, key: &str, attr: &Attribute) -> ParseResult<String> {
+        if let Some(value) = map.remove(key) {
+            if let KvValue::Lit(value) = value {
+                return Ok(value);
             } else {
-                return Err(bail_error(
-                    "#[property] attribute with a non-literal setter",
+                return bail(
+                    format!(
+                        "#[export] attribute {} with a non-literal variant_type",
+                        key
+                    ),
                     attr,
-                ));
+                )?;
             }
         } else {
-            return Err(bail_error("#[property] attribute without a setter", attr));
+            return bail(format!("#[export] attribute without a {}", key), attr);
         }
-        ensure_kv_empty(map, attr.__span())?;
-        return Ok(ExportedField {
-            field,
-            getter: export_getter,
-            setter: export_setter,
-        });
     }
 }
 
@@ -326,10 +325,12 @@ fn make_exports_impl(class_name: &Ident, fields: &Fields) -> TokenStream {
             let name = exported_field.field.name.to_string();
             let getter = proc_macro2::Literal::from_str(&exported_field.getter).unwrap();
             let setter = proc_macro2::Literal::from_str(&exported_field.setter).unwrap();
+            let vtype = &exported_field.variant_type;
+            let variant_type: TokenStream = vtype[1..vtype.len() - 1].parse().unwrap();
             quote! {
                 let class_name = ::godot::builtin::StringName::from(#class_name::CLASS_NAME);
                 let property_info = ::godot::builtin::meta::PropertyInfo::new(
-                    ::godot::sys::VariantType::Int,
+                    #variant_type,
                     ::godot::builtin::meta::ClassName::new::<#class_name>(),
                     ::godot::builtin::StringName::from(#name),
                 );

itest/godot/ManualFfiTests.gd

@@ -9,6 +9,7 @@ func run() -> bool:
 	var ok = true
 	#ok = ok && test_missing_init()
 	ok = ok && test_to_string()
+	ok = ok && test_export()
 
 	print("[GD] ManualFfi tested (passed=", ok, ")")
 	return ok
@@ -28,6 +29,20 @@ func test_to_string() -> bool:
 
 func test_export() -> bool:
 	var obj = HasProperty.new()
-	obj.val = 5
-	print("[GD] HasProperty's property is: ", obj.val, " and should be 5")
-	return obj.val == 5
+
+	obj.int_val = 5
+	print("[GD] HasProperty's int_val property is: ", obj.int_val, " and should be 5")
+	var int_val_correct = obj.int_val == 5
+
+	obj.string_val = "test val"
+	print("[GD] HasProperty's string_val property is: ", obj.string_val, " and should be \"test val\"")
+	var string_val_correct = obj.string_val == "test val"
+
+	var node = Node.new()
+	obj.object_val = node
+	print("[GD] HasProperty's object_val property is: ", obj.object_val, " and should be ", node)
+	var object_val_correct = obj.object_val == node
+
+	obj.free()
+
+	return int_val_correct && string_val_correct && object_val_correct

itest/rust/src/export_test.rs

@@ -4,11 +4,10 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
-use crate::itest;
 use godot::prelude::*;
 
 pub(crate) fn run() -> bool {
-    let mut ok = true;
+    let ok = true;
     // No tests currently, tests using HasProperty are in Godot scripts.
 
     ok
@@ -17,28 +16,73 @@ pub(crate) fn run() -> bool {
 #[derive(GodotClass)]
 #[class(base=Node)]
 struct HasProperty {
-    #[export(getter = "get_val", setter = "set_val")]
-    val: i32,
     #[base]
     base: Base<Node>,
+    #[export(
+        getter = "get_int_val",
+        setter = "set_int_val",
+        variant_type = "::godot::sys::VariantType::Int"
+    )]
+    int_val: i32,
+    #[export(
+        getter = "get_string_val",
+        setter = "set_string_val",
+        variant_type = "::godot::sys::VariantType::String"
+    )]
+    string_val: GodotString,
+    #[export(
+        getter = "get_object_val",
+        setter = "set_object_val",
+        variant_type = "::godot::sys::VariantType::Object"
+    )]
+    object_val: Option<Gd<Object>>,
 }
 
 #[godot_api]
 impl HasProperty {
     #[func]
-    pub fn get_val(&self) -> i32 {
-        return self.val;
+    pub fn get_int_val(&self) -> i32 {
+        return self.int_val;
     }
 
     #[func]
-    pub fn set_val(&mut self, val: i32) {
-        self.val = val;
+    pub fn set_int_val(&mut self, val: i32) {
+        self.int_val = val;
+    }
+
+    #[func]
+    pub fn get_string_val(&self) -> GodotString {
+        return self.string_val.clone();
+    }
+
+    #[func]
+    pub fn set_string_val(&mut self, val: GodotString) {
+        self.string_val = val;
+    }
+
+    #[func]
+    pub fn get_object_val(&self) -> Variant {
+        if let Some(object_val) = self.object_val.as_ref() {
+            return object_val.to_variant();
+        } else {
+            return Variant::nil();
+        }
+    }
+
+    #[func]
+    pub fn set_object_val(&mut self, val: Gd<Object>) {
+        self.object_val = Some(val);
     }
 }
 
 #[godot_api]
 impl GodotExt for HasProperty {
     fn init(base: Base<Node>) -> Self {
-        HasProperty { val: 0, base }
+        HasProperty {
+            int_val: 0,
+            object_val: None,
+            string_val: GodotString::new(),
+            base,
+        }
     }
 }