Add "validate_property" virtual func

Author: Yarwin

godot-codegen/src/generator/virtual_traits.rs

@@ -119,6 +119,11 @@ fn make_special_virtual_methods(notification_enum_name: &Ident) -> TokenStream {
             unimplemented!()
         }
 
+        #[cfg(since_api = "4.2")]
+        fn validate_property(&self, property: &mut crate::meta::PropertyInfo) {
+            unimplemented!()
+        }
+
         /// Called by Godot to tell if a property has a custom revert or not.
         ///
         /// Return `None` for no custom revert, and return `Some(value)` to specify the custom revert.

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

@@ -143,6 +143,17 @@ impl StringName {
         *boxed
     }
 
+    /// Moves this string into a string sys pointer. This is the same as using [`GodotFfi::move_return_ptr`].
+    ///
+    /// # Safety
+    ///
+    /// `dst` must be a valid string 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

godot-core/src/meta/property_info.rs

@@ -10,6 +10,7 @@ use crate::global::{PropertyHint, PropertyUsageFlags};
 use crate::meta::{
     element_godot_type_name, ArrayElement, ClassName, GodotType, PackedArrayElement,
 };
+use crate::obj::{EngineBitfield, EngineEnum};
 use crate::registry::property::{Export, Var};
 use crate::sys;
 use godot_ffi::VariantType;
@@ -179,6 +180,54 @@ impl PropertyInfo {
         }
     }
 
+    /// Consumes self, moving the values into `sys::GDExtensionPropertyInfo` pointer.
+    ///
+    /// # 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).hint = u32::try_from(self.hint_info.hint.ord()).expect("hint.ord()");
+
+        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);
+
+        (*property_info_ptr).usage = u32::try_from(self.usage.ord()).expect("usage.ord()");
+
+        if self.class_name != ClassName::none() {
+            (*property_info_ptr).class_name = sys::SysPtr::force_mut(self.class_name.string_sys());
+        }
+    }
+
+    /// Creates copy of given `sys::GDExtensionPropertyInfo`.
+    ///
+    /// # Safety
+    ///
+    /// * `property_info_ptr` must be valid.
+    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,
+            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

godot-core/src/obj/traits.rs

@@ -472,6 +472,7 @@ where
 pub mod cap {
     use super::*;
     use crate::builtin::{StringName, Variant};
+    use crate::meta::PropertyInfo;
     use crate::obj::{Base, Bounds, Gd};
     use std::any::Any;
 
@@ -571,6 +572,13 @@ pub mod cap {
         fn __godot_property_get_revert(&self, property: StringName) -> Option<Variant>;
     }
 
+    #[doc(hidden)]
+    #[cfg(since_api = "4.2")]
+    pub trait GodotValidateProperty: GodotClass {
+        #[doc(hidden)]
+        fn __godot_validate_property(&self, property: &mut PropertyInfo);
+    }
+
     /// Auto-implemented for `#[godot_api] impl MyClass` blocks
     pub trait ImplementsGodotApi: GodotClass {
         #[doc(hidden)]

godot-core/src/registry/callbacks.rs

@@ -13,6 +13,7 @@
 use crate::builder::ClassBuilder;
 use crate::builtin::{StringName, Variant};
 use crate::classes::Object;
+use crate::meta::PropertyInfo;
 use crate::obj::{bounds, cap, AsDyn, Base, Bounds, Gd, GodotClass, Inherits, UserClass};
 use crate::registry::plugin::ErasedDynGd;
 use crate::storage::{as_storage, InstanceStorage, Storage, StorageRefCounted};
@@ -357,6 +358,28 @@ pub unsafe extern "C" fn property_get_revert<T: cap::GodotPropertyGetRevert>(
 
     sys::conv::SYS_TRUE
 }
+
+/// # 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>(
+    instance: sys::GDExtensionClassInstancePtr,
+    property_info_ptr: *mut sys::GDExtensionPropertyInfo,
+) -> sys::GDExtensionBool {
+    // SAFETY: `instance` is a valid `T` instance pointer for the duration of this function call.
+    let storage = unsafe { as_storage::<T>(instance) };
+    let instance = storage.get();
+
+    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
+    unsafe { property_info.move_into_property_info_ptr(property_info_ptr) };
+
+    sys::conv::SYS_TRUE
+}
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 // Safe, higher-level methods
 

godot-core/src/registry/class.rs

@@ -452,6 +452,7 @@ fn fill_class_info(item: PluginItem, c: &mut ClassRegistrationInfo) {
             user_property_get_revert_fn,
             #[cfg(all(since_api = "4.3", feature = "register-docs"))]
                 virtual_method_docs: _,
+            validate_property_fn,
         }) => {
             c.user_register_fn = user_register_fn;
 
@@ -466,7 +467,10 @@ fn fill_class_info(item: PluginItem, c: &mut ClassRegistrationInfo) {
                 .expect("duplicate: recreate_instance_func (i)");
 
             #[cfg(before_api = "4.2")]
-            assert!(user_recreate_fn.is_none()); // not used
+            {
+                assert!(user_recreate_fn.is_none()); // not used
+                assert!(validate_property_fn.is_none()); // not used
+            }
 
             c.godot_params.to_string_func = user_to_string_fn;
             c.godot_params.notification_func = user_on_notification_fn;
@@ -477,6 +481,10 @@ 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;
+            #[cfg(since_api = "4.2")]
+            {
+                c.godot_params.validate_property_func = validate_property_fn;
+            }
         }
         PluginItem::DynTraitImpl(dyn_trait_impl) => {
             let type_id = dyn_trait_impl.dyn_trait_typeid();

godot-core/src/registry/plugin.rs

@@ -404,6 +404,13 @@ pub struct ITraitImpl {
             r_ret: sys::GDExtensionVariantPtr,
         ) -> sys::GDExtensionBool,
     >,
+    #[cfg(since_api = "4.2")]
+    pub(crate) validate_property_fn: Option<
+        unsafe extern "C" fn(
+            p_instance: sys::GDExtensionClassInstancePtr,
+            p_property: *mut sys::GDExtensionPropertyInfo,
+        ) -> sys::GDExtensionBool,
+    >,
 }
 
 impl ITraitImpl {
@@ -485,6 +492,15 @@ impl ITraitImpl {
         );
         self
     }
+
+    #[cfg(since_api = "4.2")]
+    pub fn with_validate_property<T: GodotClass + cap::GodotValidateProperty>(mut self) -> Self {
+        set(
+            &mut self.validate_property_fn,
+            callbacks::validate_property::<T>,
+        );
+        self
+    }
 }
 
 /// Representation of a `#[godot_dyn]` invocation.

godot-macros/src/class/data_models/interface_trait_impl.rs

@@ -25,6 +25,7 @@ pub fn transform_trait_impl(original_impl: venial::Impl) -> ParseResult<TokenStr
     let mut set_property_impl = TokenStream::new();
     let mut get_property_list_impl = TokenStream::new();
     let mut property_get_revert_impl = TokenStream::new();
+    let mut validate_property_impl = TokenStream::new();
 
     let mut modifiers = Vec::new();
 
@@ -207,6 +208,24 @@ pub fn transform_trait_impl(original_impl: venial::Impl) -> ParseResult<TokenStr
                 modifiers.push((cfg_attrs, ident("with_property_get_revert")));
             }
 
+            #[cfg(since_api = "4.2")]
+            "validate_property" => {
+                let inactive_class_early_return = make_inactive_class_check(TokenStream::new());
+                validate_property_impl = quote! {
+                    #(#cfg_attrs)*
+                    impl ::godot::obj::cap::GodotValidateProperty for #class_name {
+                        fn __godot_validate_property(&self, property: &mut ::godot::meta::PropertyInfo) {
+                            use ::godot::obj::UserClass as _;
+
+                            #inactive_class_early_return
+
+                            <Self as #trait_path>::validate_property(self, property);
+                        }
+                    }
+                };
+                modifiers.push((cfg_attrs, ident("with_validate_property")));
+            }
+
             // Other virtual methods, like ready, process etc.
             method_name_str => {
                 #[cfg(since_api = "4.4")]
@@ -315,6 +334,7 @@ pub fn transform_trait_impl(original_impl: venial::Impl) -> ParseResult<TokenStr
         #set_property_impl
         #get_property_list_impl
         #property_get_revert_impl
+        #validate_property_impl
 
         impl ::godot::private::You_forgot_the_attribute__godot_api for #class_name {}
 

itest/rust/src/object_tests/mod.rs

@@ -23,6 +23,9 @@ mod property_template_test;
 mod property_test;
 mod reentrant_test;
 mod singleton_test;
+// `validate_property` is only supported in Godot 4.2+
+#[cfg(since_api = "4.2")]
+mod validate_property_test;
 mod virtual_methods_test;
 
 // Need to test this in the init level method.

itest/rust/src/object_tests/validate_property_test.rs

@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) godot-rust; Bromeon and contributors.
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+use godot::builtin::{Array, Dictionary, GString, StringName};
+use godot::classes::IObject;
+use godot::global::PropertyUsageFlags;
+use godot::meta::PropertyInfo;
+use godot::obj::NewAlloc;
+use godot::register::{godot_api, GodotClass};
+use godot::test::itest;
+
+#[derive(GodotClass)]
+#[class(base = Object, init)]
+pub struct ValidatePropertyTest {
+    #[export]
+    my_var: i64,
+}
+
+#[godot_api]
+impl IObject for ValidatePropertyTest {
+    fn validate_property(&self, property: &mut PropertyInfo) {
+        if property.property_name.to_string() == "my_var" {
+            property.usage = PropertyUsageFlags::NO_EDITOR;
+            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
+            property.class_name = <ValidatePropertyTest as godot::obj::GodotClass>::class_name();
+        }
+    }
+}
+
+#[itest]
+fn validate_property_test() {
+    let obj = ValidatePropertyTest::new_alloc();
+    let properties: Array<Dictionary> = obj.get_property_list();
+
+    for property in properties.iter_shared() {
+        if property
+            .get("name")
+            .map(|v| v.to_string() == "SuperNewTestPropertyName")
+            .unwrap_or(false)
+        {
+            let Some(usage) = property.get("usage").map(|v| v.to::<PropertyUsageFlags>()) else {
+                continue;
+            };
+            assert_eq!(usage, PropertyUsageFlags::NO_EDITOR);
+            let Some(usage) = property.get("hint_string").map(|v| v.to::<GString>()) else {
+                continue;
+            };
+            assert_eq!(usage, GString::from("SomePropertyHint"));
+
+            obj.free();
+            return;
+        }
+    }
+
+    obj.free();
+    panic!("Test failed – unable to find validated property.");
+}