Derive property groups

- Adds support for property categories and groups:
  https://docs.godotengine.org/en/stable/tutorials/scripting/gdscript/gdscript_exports.html#adding-script-categories
  https://docs.godotengine.org/en/stable/tutorials/scripting/gdscript/gdscript_exports.html#grouping-properties

Author: parasyte

gdnative-core/src/export/property.rs

@@ -322,6 +322,29 @@ impl PropertyUsage {
     }
 }
 
+/// Marker for defining property groups.
+#[derive(Debug)]
+pub struct GroupMarker;
+
+impl crate::core_types::ToVariant for GroupMarker {
+    fn to_variant(&self) -> Variant {
+        Variant::nil()
+    }
+}
+
+impl crate::core_types::FromVariant for GroupMarker {
+    fn from_variant(variant: &Variant) -> Result<Self, FromVariantError> {
+        if variant.is_nil() {
+            Ok(Self)
+        } else {
+            Err(FromVariantError::InvalidVariantType {
+                variant_type: variant.get_type(),
+                expected: VariantType::Nil,
+            })
+        }
+    }
+}
+
 mod impl_export {
     use super::*;
 
@@ -481,4 +504,13 @@ mod impl_export {
             hint.unwrap_or_default().export_info()
         }
     }
+
+    impl Export for GroupMarker {
+        type Hint = hint::GroupHint;
+
+        #[inline]
+        fn export_info(hint: Option<Self::Hint>) -> ExportInfo {
+            hint.unwrap_or_default().export_info()
+        }
+    }
 }

gdnative-core/src/export/property/hint.rs

@@ -465,3 +465,29 @@ impl ArrayHint {
         }
     }
 }
+
+/// Provides a hint prefix for group members.
+#[derive(Clone, Debug, Default)]
+pub struct GroupHint {
+    prefix: String,
+}
+
+impl GroupHint {
+    /// Returns a `GroupHint` with a specific prefix.
+    #[inline]
+    pub fn new<S: ToString>(prefix: S) -> Self {
+        Self {
+            prefix: prefix.to_string(),
+        }
+    }
+
+    #[inline]
+    pub fn export_info(self) -> ExportInfo {
+        ExportInfo {
+            variant_type: VariantType::Nil,
+            // hint_kind: sys::godot_property_hint_GODOT_PROPERTY_HINT_TYPE_STRING,
+            hint_kind: sys::godot_property_hint_GODOT_PROPERTY_HINT_NONE,
+            hint_string: GodotString::from_str(&self.prefix),
+        }
+    }
+}

gdnative-derive/src/native_script.rs

@@ -64,11 +64,32 @@ pub(crate) fn derive_native_class(derive_input: &DeriveInput) -> Result<TokenStr
         let properties = data.properties.into_iter().map(|(ident, config)| {
             let with_default = config
                 .default
+                .as_ref()
                 .map(|default_value| quote!(.with_default(#default_value)));
-            let with_hint = config.hint.map(|hint_fn| quote!(.with_hint(#hint_fn())));
+            let with_hint = config
+                .hint
+                .as_ref()
+                .map(|hint_fn| quote!(.with_hint(#hint_fn())))
+                .or_else(|| {
+                    if let Some(Some(prefix)) = &config.group {
+                        Some(quote!(.with_hint(::gdnative::export::hint::GroupHint::new(#prefix))))
+                    } else {
+                        None
+                    }
+                });
 
             let with_usage = if config.no_editor {
                 Some(quote!(.with_usage(::gdnative::export::PropertyUsage::NOEDITOR)))
+            } else if config.group.is_some() {
+                Some(quote!(.with_usage({
+                    ::gdnative::export::PropertyUsage::DEFAULT
+                    | ::gdnative::export::PropertyUsage::GROUP
+                })))
+            } else if config.category {
+                Some(quote!(.with_usage({
+                    ::gdnative::export::PropertyUsage::DEFAULT
+                    | ::gdnative::export::PropertyUsage::CATEGORY
+                })))
             } else {
                 None
             };

gdnative-derive/src/native_script/property_args.rs

@@ -9,6 +9,8 @@ pub struct PropertyAttrArgs {
     pub before_set: Option<syn::Path>,
     pub after_set: Option<syn::Path>,
     pub no_editor: bool,
+    pub group: Option<Option<String>>,
+    pub category: bool,
 }
 
 #[derive(Default)]
@@ -21,6 +23,8 @@ pub struct PropertyAttrArgsBuilder {
     before_set: Option<syn::Path>,
     after_set: Option<syn::Path>,
     no_editor: bool,
+    group: Option<Option<String>>,
+    category: bool,
 }
 
 impl PropertyAttrArgsBuilder {
@@ -83,6 +87,23 @@ impl PropertyAttrArgsBuilder {
                     ));
                 }
             }
+            "group" => {
+                let string = if let syn::Lit::Str(lit_str) = &pair.lit {
+                    lit_str.value()
+                } else {
+                    return Err(syn::Error::new(
+                        pair.span(),
+                        "group hint is not a string literal".to_string(),
+                    ));
+                };
+
+                if let Some(old) = self.group.replace(Some(string)) {
+                    return Err(syn::Error::new(
+                        pair.span(),
+                        format!("there is already a group set: {:?}", old),
+                    ));
+                }
+            }
             "before_get" => {
                 let string = if let syn::Lit::Str(lit_str) = &pair.lit {
                     lit_str.value()
@@ -173,6 +194,10 @@ impl PropertyAttrArgsBuilder {
     pub fn add_path(&mut self, path: &syn::Path) -> Result<(), syn::Error> {
         if path.is_ident("no_editor") {
             self.no_editor = true;
+        } else if path.is_ident("group") {
+            self.group = Some(None);
+        } else if path.is_ident("category") {
+            self.category = true;
         } else {
             return Err(syn::Error::new(
                 path.span(),
@@ -195,6 +220,8 @@ impl PropertyAttrArgsBuilder {
             before_set: self.before_set,
             after_set: self.after_set,
             no_editor: self.no_editor,
+            group: self.group,
+            category: self.category,
         }
     }
 }