Add "validate_property" virtual func

- Create internal API for easier handling of ``*mut GDExtensionPropertyInfo` - functions that allow to easily handle conversions from/to PropertyInfo and `borrow_string_sys_mut` for GString and StringName.
- Properly drop refcounted values in exposed Godot's PropertyInfo while assigning new values to given memory locations.

Author: Yarwin

godot-core/src/builtin/string/gstring.rs

@@ -148,6 +148,16 @@ impl GString {
         *boxed
     }
 
+    /// Convert a `GString` sys pointer to a mutable reference with unbounded lifetime.
+    ///
+    /// # Safety
+    ///
+    /// `ptr` must point to a live `GString` for the duration of `'a`.
+    pub(crate) unsafe fn borrow_string_sys_mut<'a>(ptr: sys::GDExtensionStringPtr) -> &'a mut Self {
+        sys::static_assert_eq_size_align!(StringName, sys::types::OpaqueString);
+        &mut *(ptr.cast::<GString>())
+    }
+
     /// Moves this string into a string sys pointer. This is the same as using [`GodotFfi::move_return_ptr`].
     ///
     /// # Safety

godot-core/src/builtin/string/string_name.rs

@@ -56,7 +56,7 @@ pub struct StringName {
 }
 
 impl StringName {
-    fn from_opaque(opaque: sys::types::OpaqueStringName) -> Self {
+    pub(crate) fn from_opaque(opaque: sys::types::OpaqueStringName) -> Self {
         Self { opaque }
     }
 
@@ -143,17 +143,6 @@ impl StringName {
         *boxed
     }
 
-    /// Moves this string into a string name sys pointer. This is the same as using [`GodotFfi::move_return_ptr`].
-    ///
-    /// # Safety
-    ///
-    /// `dst` must be a valid string name pointer.
-    pub(crate) unsafe fn move_into_string_ptr(self, dst: sys::GDExtensionStringNamePtr) {
-        let dst: sys::GDExtensionTypePtr = dst.cast();
-
-        self.move_return_ptr(dst, sys::PtrcallType::Standard);
-    }
-
     /// Convert a `StringName` sys pointer to a reference with unbounded lifetime.
     ///
     /// # Safety
@@ -166,6 +155,18 @@ impl StringName {
         &*(ptr.cast::<StringName>())
     }
 
+    /// Convert a `StringName` sys pointer to a mutable reference with unbounded lifetime.
+    ///
+    /// # Safety
+    ///
+    /// * `ptr` must point to a live `StringName` for the duration of `'a`.
+    pub(crate) unsafe fn borrow_string_sys_mut<'a>(
+        ptr: sys::GDExtensionStringNamePtr,
+    ) -> &'a mut StringName {
+        sys::static_assert_eq_size_align!(StringName, sys::types::OpaqueStringName);
+        &mut *(ptr.cast::<StringName>())
+    }
+
     #[doc(hidden)]
     pub fn as_inner(&self) -> inner::InnerStringName {
         inner::InnerStringName::from_outer(self)

godot-core/src/meta/property_info.rs

@@ -180,28 +180,42 @@ impl PropertyInfo {
         }
     }
 
-    /// Consumes self, moving the values into `sys::GDExtensionPropertyInfo` pointer.
+    /// Properly frees a `sys::GDExtensionPropertyInfo` created by [`into_owned_property_sys`](Self::into_owned_property_sys).
+    ///
+    /// # Safety
+    ///
+    /// * Must only be used on a struct returned from a call to `into_owned_property_sys`, without modification.
+    /// * Must not be called more than once on a `sys::GDExtensionPropertyInfo` struct.
+    pub(crate) unsafe fn free_owned_property_sys(info: sys::GDExtensionPropertyInfo) {
+        // SAFETY: This function was called on a pointer returned from `into_owned_property_sys`, thus both `info.name` and
+        // `info.hint_string` were created from calls to `into_owned_string_sys` on their respective types.
+        // Additionally, this function isn't called more than once on a struct containing the same `name` or `hint_string` pointers.
+        unsafe {
+            let _name = StringName::from_owned_string_sys(info.name);
+            let _hint_string = GString::from_owned_string_sys(info.hint_string);
+        }
+    }
+    /// Moves its values into given `GDExtensionPropertyInfo`, dropping previous values if necessary.
     ///
     /// # Safety
     ///
     /// * `property_info_ptr` must be valid.
+    ///
     pub(crate) unsafe fn move_into_property_info_ptr(
         self,
         property_info_ptr: *mut sys::GDExtensionPropertyInfo,
     ) {
-        (*property_info_ptr).type_ = self.variant_type.sys();
+        (*property_info_ptr).usage = u32::try_from(self.usage.ord()).expect("usage.ord()");
         (*property_info_ptr).hint = u32::try_from(self.hint_info.hint.ord()).expect("hint.ord()");
+        (*property_info_ptr).type_ = self.variant_type.sys();
 
-        self.hint_info
-            .hint_string
-            .move_into_string_ptr((*property_info_ptr).hint_string);
-        self.property_name
-            .move_into_string_ptr((*property_info_ptr).name);
+        let ptr = *property_info_ptr;
 
-        (*property_info_ptr).usage = u32::try_from(self.usage.ord()).expect("usage.ord()");
+        *StringName::borrow_string_sys_mut(ptr.name) = self.property_name;
+        *GString::borrow_string_sys_mut(ptr.hint_string) = self.hint_info.hint_string;
 
         if self.class_name != ClassName::none() {
-            (*property_info_ptr).class_name = sys::SysPtr::force_mut(self.class_name.string_sys());
+            *StringName::borrow_string_sys_mut(ptr.class_name) = self.class_name.to_string_name();
         }
     }
 
@@ -213,34 +227,15 @@ impl PropertyInfo {
     pub(crate) unsafe fn new_from_sys(
         property_info_ptr: *mut sys::GDExtensionPropertyInfo,
     ) -> Self {
-        let variant_type = VariantType::from_sys((*property_info_ptr).type_);
-        let property_name = StringName::new_from_string_sys((*property_info_ptr).name);
-        let hint_string = GString::new_from_string_sys((*property_info_ptr).hint_string);
-        let hint = PropertyHint::from_ord((*property_info_ptr).hint.to_owned() as i32);
-        let usage = PropertyUsageFlags::from_ord((*property_info_ptr).usage as u64);
-
         Self {
-            variant_type,
+            variant_type: VariantType::from_sys((*property_info_ptr).type_),
             class_name: ClassName::none(),
-            property_name,
-            hint_info: PropertyHintInfo { hint, hint_string },
-            usage,
-        }
-    }
-
-    /// Properly frees a `sys::GDExtensionPropertyInfo` created by [`into_owned_property_sys`](Self::into_owned_property_sys).
-    ///
-    /// # Safety
-    ///
-    /// * Must only be used on a struct returned from a call to `into_owned_property_sys`, without modification.
-    /// * Must not be called more than once on a `sys::GDExtensionPropertyInfo` struct.
-    pub(crate) unsafe fn free_owned_property_sys(info: sys::GDExtensionPropertyInfo) {
-        // SAFETY: This function was called on a pointer returned from `into_owned_property_sys`, thus both `info.name` and
-        // `info.hint_string` were created from calls to `into_owned_string_sys` on their respective types.
-        // Additionally, this function isn't called more than once on a struct containing the same `name` or `hint_string` pointers.
-        unsafe {
-            let _name = StringName::from_owned_string_sys(info.name);
-            let _hint_string = GString::from_owned_string_sys(info.hint_string);
+            property_name: StringName::new_from_string_sys((*property_info_ptr).name),
+            hint_info: PropertyHintInfo {
+                hint: PropertyHint::from_ord((*property_info_ptr).hint.to_owned() as i32),
+                hint_string: GString::new_from_string_sys((*property_info_ptr).hint_string),
+            },
+            usage: PropertyUsageFlags::from_ord((*property_info_ptr).usage as u64),
         }
     }
 }

godot-core/src/registry/callbacks.rs

@@ -359,10 +359,15 @@ pub unsafe extern "C" fn property_get_revert<T: cap::GodotPropertyGetRevert>(
     sys::conv::SYS_TRUE
 }
 
+/// Callback for `validate_property`.
+///
+/// Exposes `PropertyInfo` created out of `*mut GDExtensionPropertyInfo` ptr to user and moves edited values back to the pointer.
+///
 /// # Safety
 ///
 /// - Must only be called by Godot as a callback for `validate_property` for a rust-defined class of type `T`.
 /// - `sys_property_info` must be valid for the whole duration of this function call (ie - can't be freed nor consumed).
+///
 #[deny(unsafe_op_in_unsafe_fn)]
 #[cfg(since_api = "4.2")]
 pub unsafe extern "C" fn validate_property<T: cap::GodotValidateProperty>(
@@ -375,7 +380,8 @@ pub unsafe extern "C" fn validate_property<T: cap::GodotValidateProperty>(
 
     let mut property_info = unsafe { PropertyInfo::new_from_sys(property_info_ptr) };
     T::__godot_validate_property(&*instance, &mut property_info);
-    // SAFETY: property_info_ptr is still valid
+
+    // SAFETY: property_info_ptr remains valid & unchanged.
     unsafe { property_info.move_into_property_info_ptr(property_info_ptr) };
 
     sys::conv::SYS_TRUE

godot-core/src/registry/class.rs

@@ -479,7 +479,7 @@ fn fill_class_info(item: PluginItem, c: &mut ClassRegistrationInfo) {
             c.godot_params.property_can_revert_func = user_property_can_revert_fn;
             c.godot_params.property_get_revert_func = user_property_get_revert_fn;
             c.user_virtual_fn = get_virtual_fn;
-            // Not present in GdExtension
+            // Not present in GdExtension.
             #[cfg(since_api = "4.2")]
             {
                 c.godot_params.validate_property_func = validate_property_fn;

itest/rust/src/object_tests/mod.rs

@@ -23,7 +23,7 @@ mod property_template_test;
 mod property_test;
 mod reentrant_test;
 mod singleton_test;
-// `validate_property` is only supported in Godot 4.2+
+// `validate_property` is only supported in Godot 4.2+.
 #[cfg(since_api = "4.2")]
 mod validate_property_test;
 mod virtual_methods_test;

itest/rust/src/object_tests/validate_property_test.rs

@@ -16,6 +16,10 @@ use godot::test::itest;
 #[derive(GodotClass)]
 #[class(base = Object, init)]
 pub struct ValidatePropertyTest {
+    #[var(
+        hint = NONE,
+        hint_string = "initial"
+    )]
     #[export]
     my_var: i64,
 }
@@ -28,7 +32,7 @@ impl IObject for ValidatePropertyTest {
             property.property_name = StringName::from("SuperNewTestPropertyName");
             property.hint_info.hint_string = GString::from("SomePropertyHint");
 
-            // Makes no sense but allows to check if given ClassName can be properly moved to GDExtensionPropertyInfo
+            // Makes no sense but allows to check if given ClassName can be properly moved to GDExtensionPropertyInfo.
             property.class_name = <ValidatePropertyTest as godot::obj::GodotClass>::class_name();
         }
     }
@@ -40,24 +44,30 @@ fn validate_property_test() {
     let properties: Array<Dictionary> = obj.get_property_list();
 
     for property in properties.iter_shared() {
-        if property
+        if !property
             .get("name")
-            .map(|v| v.to_string() == "SuperNewTestPropertyName")
-            .unwrap_or(false)
+            .is_some_and(|v| v.to_string() == "SuperNewTestPropertyName")
         {
-            let Some(usage) = property.get("usage").map(|v| v.to::<PropertyUsageFlags>()) else {
-                continue;
-            };
-            assert_eq!(usage, PropertyUsageFlags::NO_EDITOR);
+            continue;
+        }
 
-            let Some(usage) = property.get("hint_string").map(|v| v.to::<GString>()) else {
-                continue;
-            };
-            assert_eq!(usage, GString::from("SomePropertyHint"));
+        let Some(hint_string) = property.get("hint_string").map(|v| v.to::<GString>()) else {
+            continue;
+        };
+        assert_eq!(hint_string, GString::from("SomePropertyHint"));
 
-            obj.free();
-            return;
-        }
+        let Some(class) = property.get("class_name").map(|v| v.to::<StringName>()) else {
+            continue;
+        };
+        assert_eq!(class, StringName::from("ValidatePropertyTest"));
+
+        let Some(usage) = property.get("usage").map(|v| v.to::<PropertyUsageFlags>()) else {
+            continue;
+        };
+        assert_eq!(usage, PropertyUsageFlags::NO_EDITOR);
+
+        obj.free();
+        return;
     }
 
     obj.free();