Add property_get_revert

Add `property_can_revert`

Author: lilizoey

godot-codegen/src/generator/virtual_traits.rs

@@ -115,6 +115,23 @@ fn special_virtual_methods(notification_enum_name: &Ident) -> TokenStream {
         fn get_property_list(&mut self) -> Vec<crate::builtin::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.
+        ///
+        /// This is a combination of Godot's [`Object::_property_get_revert`] and [`Object::_property_can_revert`]. This means that this
+        /// function will usually be called twice by Godot to find the revert.
+        ///
+        /// Note that this should be a _pure_ function. That is, it should always return the same value for a property as long as `self`
+        /// remains unchanged. Otherwise this may lead to unexpected (safe) behavior.
+        ///
+        /// [`Object::_property_get_revert`]: https://docs.godotengine.org/en/latest/classes/class_object.html#class-object-private-method-property-get-revert
+        /// [`Object::_property_can_revert`]: https://docs.godotengine.org/en/latest/classes/class_object.html#class-object-private-method-property-can-revert
+        #[doc(alias = "property_can_revert")]
+        fn property_get_revert(&self, property: StringName) -> Option<Variant> {
+            unimplemented!()
+        }
     }
 }
 

godot-core/src/builtin/meta/mod.rs

@@ -324,7 +324,6 @@ impl PropertyInfo {
     ///
     /// Creating an `@export_range` property.
     ///
-
     // TODO: Make this nicer to use.
     /// ```no_run
     /// # use crate::property::export_info_function;

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

@@ -136,6 +136,8 @@ impl GString {
     ///
     /// This will leak memory unless `from_owned_string_sys` is called on the returned pointer.
     pub(crate) fn into_owned_string_sys(self) -> sys::GDExtensionStringPtr {
+        sys::static_assert_eq_size_align!(StringName, sys::types::OpaqueString);
+
         let leaked = Box::into_raw(Box::new(self));
         leaked.cast()
     }
@@ -148,6 +150,8 @@ impl GString {
     /// * Must not be called more than once on the same pointer.
     #[deny(unsafe_op_in_unsafe_fn)]
     pub(crate) unsafe fn from_owned_string_sys(ptr: sys::GDExtensionStringPtr) -> Self {
+        sys::static_assert_eq_size_align!(StringName, sys::types::OpaqueString);
+
         let ptr = ptr.cast::<Self>();
         let boxed = unsafe { Box::from_raw(ptr) };
         *boxed

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

@@ -131,6 +131,8 @@ impl StringName {
     /// * Must not be called more than once on the same pointer.
     #[deny(unsafe_op_in_unsafe_fn)]
     pub(crate) unsafe fn from_owned_string_sys(ptr: sys::GDExtensionStringNamePtr) -> Self {
+        sys::static_assert_eq_size_align!(StringName, sys::types::OpaqueStringName);
+
         let ptr = ptr.cast::<Self>();
         let boxed = unsafe { Box::from_raw(ptr) };
         *boxed

godot-core/src/obj/traits.rs

@@ -510,6 +510,12 @@ pub mod cap {
         fn __godot_get_property_list(&mut self) -> Vec<crate::builtin::meta::PropertyInfo>;
     }
 
+    #[doc(hidden)]
+    pub trait GodotPropertyGetRevert: GodotClass {
+        #[doc(hidden)]
+        fn __godot_property_get_revert(&self, property: StringName) -> Option<Variant>;
+    }
+
     /// Auto-implemented for `#[godot_api] impl MyClass` blocks
     pub trait ImplementsGodotApi: GodotClass {
         #[doc(hidden)]

godot-core/src/registry/callbacks.rs

@@ -248,6 +248,54 @@ pub unsafe extern "C" fn free_property_list<T: cap::GodotGetPropertyList>(
         }
     }
 }
+
+/// # Safety
+///
+/// * `instance` must be a valid `T` instance pointer for the duration of this function call.
+/// * `property_name` must be a valid `StringName` pointer for the duration of this function call.
+#[deny(unsafe_op_in_unsafe_fn)]
+unsafe fn raw_property_get_revert<T: cap::GodotPropertyGetRevert>(
+    instance: sys::GDExtensionClassInstancePtr,
+    property_name: sys::GDExtensionConstStringNamePtr,
+) -> Option<Variant> {
+    // 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();
+
+    // SAFETY: `property_name` is a valid `StringName` pointer for the duration of this function call.
+    let property = unsafe { StringName::borrow_string_sys(property_name) };
+    T::__godot_property_get_revert(&*instance, property.clone())
+}
+
+#[deny(unsafe_op_in_unsafe_fn)]
+pub unsafe extern "C" fn property_can_revert<T: cap::GodotPropertyGetRevert>(
+    instance: sys::GDExtensionClassInstancePtr,
+    property_name: sys::GDExtensionConstStringNamePtr,
+) -> sys::GDExtensionBool {
+    // SAFETY: Godot provides us with a valid `T` instance pointer and `StringName` pointer for the duration of this call.
+    let revert = unsafe { raw_property_get_revert::<T>(instance, property_name) };
+
+    revert.is_some() as sys::GDExtensionBool
+}
+
+#[deny(unsafe_op_in_unsafe_fn)]
+pub unsafe extern "C" fn property_get_revert<T: cap::GodotPropertyGetRevert>(
+    instance: sys::GDExtensionClassInstancePtr,
+    property_name: sys::GDExtensionConstStringNamePtr,
+    ret: sys::GDExtensionVariantPtr,
+) -> sys::GDExtensionBool {
+    // SAFETY: Godot provides us with a valid `T` instance pointer and `StringName` pointer for the duration of this call.
+    let Some(revert) = (unsafe { raw_property_get_revert::<T>(instance, property_name) }) else {
+        return false as sys::GDExtensionBool;
+    };
+
+    // SAFETY: Godot provides us with a valid `Variant` pointer.
+    unsafe {
+        revert.move_into_var_ptr(ret);
+    }
+
+    true as sys::GDExtensionBool
+}
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 // Safe, higher-level methods
 

godot-core/src/registry/mod.rs

@@ -205,6 +205,21 @@ pub enum PluginItem {
                 p_count: u32,
             ),
         >,
+
+        user_property_can_revert_fn: Option<
+            unsafe extern "C" fn(
+                p_instance: sys::GDExtensionClassInstancePtr,
+                p_name: sys::GDExtensionConstStringNamePtr,
+            ) -> sys::GDExtensionBool,
+        >,
+
+        user_property_get_revert_fn: Option<
+            unsafe extern "C" fn(
+                p_instance: sys::GDExtensionClassInstancePtr,
+                p_name: sys::GDExtensionConstStringNamePtr,
+                r_ret: sys::GDExtensionVariantPtr,
+            ) -> sys::GDExtensionBool,
+        >,
     },
 }
 
@@ -478,6 +493,8 @@ fn fill_class_info(item: PluginItem, c: &mut ClassRegistrationInfo) {
             get_virtual_fn,
             user_get_property_list_fn,
             user_free_property_list_fn,
+            user_property_can_revert_fn,
+            user_property_get_revert_fn,
         } => {
             c.user_register_fn = user_register_fn;
 
@@ -500,6 +517,8 @@ fn fill_class_info(item: PluginItem, c: &mut ClassRegistrationInfo) {
             c.godot_params.get_func = user_get_fn;
             c.godot_params.get_property_list_func = user_get_property_list_fn;
             c.godot_params.free_property_list_func = user_free_property_list_fn;
+            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 = Some(get_virtual_fn);
         }
     }

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

@@ -22,6 +22,8 @@ pub fn transform_trait_impl(original_impl: venial::Impl) -> ParseResult<TokenStr
     let mut on_notification_impl = TokenStream::new();
     let mut get_property_impl = TokenStream::new();
     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 register_fn = None;
     let mut create_fn = None;
@@ -30,6 +32,10 @@ pub fn transform_trait_impl(original_impl: venial::Impl) -> ParseResult<TokenStr
     let mut on_notification_fn = None;
     let mut get_property_fn = None;
     let mut set_property_fn = None;
+    let mut get_property_list_fn = None;
+    let mut free_property_list_fn = None;
+    let mut property_get_revert_fn = None;
+    let mut property_can_revert_fn = None;
 
     let mut virtual_methods = vec![];
     let mut virtual_method_cfg_attrs = vec![];
@@ -204,6 +210,76 @@ pub fn transform_trait_impl(original_impl: venial::Impl) -> ParseResult<TokenStr
                 });
             }
 
+            #[cfg(before_api = "4.3")]
+            "get_property_list" => {
+                get_property_list_impl = quote! {
+                    #(#cfg_attrs)*
+                    compile_error!("`get_property_list` is only supported for Godot versions of at least 4.3");
+                };
+
+                // Set these variables otherwise rust complains that these variables arent changed in Godot < 4.3.
+                get_property_list_fn = None;
+                free_property_list_fn = None;
+            }
+
+            #[cfg(since_api = "4.3")]
+            "get_property_list" => {
+                get_property_list_impl = quote! {
+                    #(#cfg_attrs)*
+                    impl ::godot::obj::cap::GodotGetPropertyList for #class_name {
+                        fn __godot_get_property_list(&mut self) -> Vec<::godot::builtin::meta::PropertyInfo> {
+                            // Only supported in godot api > 4.3. If support is added for earlier versions this is still needed.
+                            //
+                            // use ::godot::obj::UserClass as _;
+                            //
+                            // #[cfg(before_api = "4.3")]
+                            // if ::godot::private::is_class_inactive(Self::__config().is_tool) {
+                            //     return false;
+                            // }
+
+                            <Self as #trait_path>::get_property_list(self)
+                        }
+                    }
+                };
+
+                get_property_list_fn = Some(quote! {
+                    #(#cfg_attrs)*
+                    () => Some(#prv::callbacks::get_property_list::<#class_name>),
+                });
+                free_property_list_fn = Some(quote! {
+                    #(#cfg_attrs)*
+                    () => Some(#prv::callbacks::free_property_list::<#class_name>),
+                });
+            }
+
+            "property_get_revert" => {
+                property_get_revert_impl = quote! {
+                    #(#cfg_attrs)*
+                    impl ::godot::obj::cap::GodotPropertyGetRevert for #class_name {
+                        fn __godot_property_get_revert(&self, property: StringName) -> Option<::godot::builtin::Variant> {
+                            use ::godot::obj::UserClass as _;
+
+                            #[cfg(before_api = "4.3")]
+                            if ::godot::private::is_class_inactive(Self::__config().is_tool) {
+                                return None;
+                            }
+
+                            <Self as #trait_path>::property_get_revert(self, property)
+                        }
+                    }
+                };
+
+                property_get_revert_fn = Some(quote! {
+                    #(#cfg_attrs)*
+                    () => Some(#prv::callbacks::property_get_revert::<#class_name>),
+                });
+
+                property_can_revert_fn = Some(quote! {
+                    #(#cfg_attrs)*
+                    () => Some(#prv::callbacks::property_can_revert::<#class_name>),
+                });
+            }
+
             // Other virtual methods, like ready, process etc.
             _ => {
                 let method = util::reduce_to_signature(method);
@@ -274,6 +350,10 @@ pub fn transform_trait_impl(original_impl: venial::Impl) -> ParseResult<TokenStr
     let on_notification_fn = convert_to_match_expression_or_none(on_notification_fn);
     let get_property_fn = convert_to_match_expression_or_none(get_property_fn);
     let set_property_fn = convert_to_match_expression_or_none(set_property_fn);
+    let get_property_list_fn = convert_to_match_expression_or_none(get_property_list_fn);
+    let free_property_list_fn = convert_to_match_expression_or_none(free_property_list_fn);
+    let property_get_revert_fn = convert_to_match_expression_or_none(property_get_revert_fn);
+    let property_can_revert_fn = convert_to_match_expression_or_none(property_can_revert_fn);
 
     let result = quote! {
         #original_impl
@@ -283,6 +363,8 @@ pub fn transform_trait_impl(original_impl: venial::Impl) -> ParseResult<TokenStr
         #register_class_impl
         #get_property_impl
         #set_property_impl
+        #get_property_list_impl
+        #property_get_revert_impl
 
         impl ::godot::private::You_forgot_the_attribute__godot_api for #class_name {}
 
@@ -312,6 +394,10 @@ pub fn transform_trait_impl(original_impl: venial::Impl) -> ParseResult<TokenStr
                 user_on_notification_fn: #on_notification_fn,
                 user_set_fn: #set_property_fn,
                 user_get_fn: #get_property_fn,
+                user_get_property_list_fn: #get_property_list_fn,
+                user_free_property_list_fn: #free_property_list_fn,
+                user_property_get_revert_fn: #property_get_revert_fn,
+                user_property_can_revert_fn: #property_can_revert_fn,
                 get_virtual_fn: #prv::callbacks::get_virtual::<#class_name>,
             },
             init_level: <#class_name as ::godot::obj::GodotClass>::INIT_LEVEL,

itest/rust/src/object_tests/virtual_methods_test.rs

@@ -282,6 +282,34 @@ impl IRefCounted for SetTest {
 
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 
+#[derive(GodotClass)]
+#[class(init)]
+struct RevertTest {}
+
+#[godot_api]
+impl IRefCounted for RevertTest {
+    fn property_get_revert(&self, property: StringName) -> Option<Variant> {
+        use std::sync::atomic::AtomicUsize;
+
+        static INC: AtomicUsize = AtomicUsize::new(0);
+
+        match String::from(property).as_str() {
+            "property_not_revert" => None,
+            "property_do_revert" => Some(GString::from("hello!").to_variant()),
+            "property_changes" => {
+                if INC.fetch_add(1, std::sync::atomic::Ordering::AcqRel) % 2 == 0 {
+                    None
+                } else {
+                    Some(true.to_variant())
+                }
+            }
+            _ => None,
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------------------------------------------------------------------------
+
 #[itest]
 fn test_to_string() {
     let _obj = VirtualMethodTest::new_gd();
@@ -563,6 +591,32 @@ fn test_set_sets_correct() {
     assert_eq!(obj.bind().settable, 500);
 }
 
+#[itest]
+fn test_revert() {
+    let revert = RevertTest::new_gd();
+
+    let not_revert = StringName::from("property_not_revert");
+    let do_revert = StringName::from("property_do_revert");
+    let changes = StringName::from("property_changes");
+
+    assert!(!revert.property_can_revert(not_revert.clone()));
+    assert_eq!(revert.property_get_revert(not_revert), Variant::nil());
+    assert!(revert.property_can_revert(do_revert.clone()));
+    assert_eq!(
+        revert.property_get_revert(do_revert),
+        GString::from("hello!").to_variant()
+    );
+
+    assert!(!revert.property_can_revert(changes.clone()));
+    assert!(revert.property_can_revert(changes.clone()));
+
+    assert_eq!(revert.property_get_revert(changes.clone()), Variant::nil());
+    assert_eq!(
+        revert.property_get_revert(changes.clone()),
+        true.to_variant()
+    );
+}
+
 // Used in `test_collision_object_2d_input_event` in `SpecialTests.gd`.
 #[derive(GodotClass)]
 #[class(init, base = RigidBody2D)]