Emit POSTINITIALIZE notification after init()

Author: beicause

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

@@ -328,7 +328,11 @@ impl From<&str> for GString {
 
         unsafe {
             Self::new_with_string_uninit(|string_ptr| {
+                #[cfg(before_api = "4.3")]
                 let ctor = interface_fn!(string_new_with_utf8_chars_and_len);
+                #[cfg(since_api = "4.3")]
+                let ctor = interface_fn!(string_new_with_utf8_chars_and_len2);
+
                 ctor(
                     string_ptr,
                     bytes.as_ptr() as *const std::ffi::c_char,

godot-core/src/classes/class_runtime.rs

@@ -170,10 +170,15 @@ pub(crate) fn construct_engine_object<T>() -> Gd<T>
 where
     T: GodotClass + Bounds<Declarer = bounds::DeclEngine>,
 {
-    // SAFETY: adhere to Godot API; valid class name and returned pointer is an object.
     unsafe {
-        let object_ptr = sys::interface_fn!(classdb_construct_object)(T::class_name().string_sys());
-        Gd::from_obj_sys(object_ptr)
+        let object_ptr = sys::classdb_construct_object(T::class_name().string_sys());
+        let obj = Gd::<T>::from_obj_sys(object_ptr);
+        if cfg!(since_api = "4.4") {
+            obj.clone()
+                .upcast_object()
+                .notify(crate::classes::notify::ObjectNotification::POSTINITIALIZE);
+        }
+        obj
     }
 }
 

godot-core/src/obj/base.rs

@@ -166,15 +166,15 @@ impl<T: GodotClass> Base<T> {
         (*self.obj).clone()
     }
 
-    /// Returns a [`Gd`] referencing the base object, for exclusive use during object initialization.
+    /// Returns a [`Gd`] referencing the base object, for exclusive use during object initialization and `NOTIFICATION_POSTINITIALIZE`.
     ///
-    /// Can be used during an initialization function [`I*::init()`][crate::classes::IObject::init] or [`Gd::from_init_fn()`].
+    /// Can be used during an initialization function [`I*::init()`][crate::classes::IObject::init] or [`Gd::from_init_fn()`], or [`POSTINITIALIZE`][crate::classes::notify::ObjectNotification::POSTINITIALIZE].
     ///
     /// The base pointer is only pointing to a base object; you cannot yet downcast it to the object being constructed.
     /// The instance ID is the same as the one the in-construction object will have.
     ///
     /// # Lifecycle for ref-counted classes
-    /// If `T: Inherits<RefCounted>`, then the ref-counted object is not yet fully-initialized at the time of the `init` function running.
+    /// If `T: Inherits<RefCounted>`, then the ref-counted object is not yet fully-initialized at the time of the `init` function and [`POSTINITIALIZE`][crate::classes::notify::ObjectNotification::POSTINITIALIZE] running.
     /// Accessing the base object without further measures would be dangerous. Here, godot-rust employs a workaround: the `Base` object (which
     /// holds a weak pointer to the actual instance) is temporarily upgraded to a strong pointer, preventing use-after-free.
     ///

godot-core/src/obj/bounds.rs

@@ -398,11 +398,7 @@ impl Declarer for DeclEngine {
     where
         T: GodotDefault + Bounds<Declarer = Self>,
     {
-        unsafe {
-            let object_ptr =
-                sys::interface_fn!(classdb_construct_object)(T::class_name().string_sys());
-            Gd::from_obj_sys(object_ptr)
-        }
+        crate::classes::construct_engine_object()
     }
 }
 

godot-core/src/obj/gd.rs

@@ -155,7 +155,7 @@ where
     where
         F: FnOnce(crate::obj::Base<T::Base>) -> T,
     {
-        let object_ptr = callbacks::create_custom(init) // or propagate panic.
+        let object_ptr = callbacks::create_custom(init, true) // or propagate panic.
             .unwrap_or_else(|payload| PanicPayload::repanic(payload));
 
         unsafe { Gd::from_obj_sys(object_ptr) }

godot-core/src/registry/callbacks.rs

@@ -25,6 +25,14 @@ use crate::private::{handle_panic, PanicPayload};
 use crate::registry::plugin::ErasedDynGd;
 use crate::storage::{as_storage, InstanceStorage, Storage, StorageRefCounted};
 
+#[cfg(since_api = "4.4")]
+unsafe fn notify_postinit(base_ptr: sys::GDExtensionObjectPtr) {
+    // Should notify it with a weak pointer, during `NOTIFICATION_POSTINITIALIZE`, ref-counted object is not yet fully-initialized.
+    let mut obj = Gd::<Object>::from_obj_sys_weak(base_ptr);
+    obj.notify(crate::classes::notify::ObjectNotification::POSTINITIALIZE);
+    std::mem::forget(obj);
+}
+
 /// Godot FFI default constructor.
 ///
 /// If the `init()` constructor panics, null is returned.
@@ -35,14 +43,18 @@ pub unsafe extern "C" fn create<T: cap::GodotDefault>(
     _class_userdata: *mut std::ffi::c_void,
     _notify_postinitialize: sys::GDExtensionBool,
 ) -> sys::GDExtensionObjectPtr {
-    create_custom(T::__godot_user_init).unwrap_or(std::ptr::null_mut())
+    create_custom(
+        T::__godot_user_init,
+        sys::conv::bool_from_sys(_notify_postinitialize),
+    )
+    .unwrap_or(std::ptr::null_mut())
 }
 
 #[cfg(before_api = "4.4")]
 pub unsafe extern "C" fn create<T: cap::GodotDefault>(
     _class_userdata: *mut std::ffi::c_void,
 ) -> sys::GDExtensionObjectPtr {
-    create_custom(T::__godot_user_init).unwrap_or(std::ptr::null_mut())
+    create_custom(T::__godot_user_init, true).unwrap_or(std::ptr::null_mut())
 }
 
 /// Workaround for <https://github.com/godot-rust/gdext/issues/874> before Godot 4.5.
@@ -71,7 +83,7 @@ pub unsafe extern "C" fn recreate<T: cap::GodotDefault>(
     _class_userdata: *mut std::ffi::c_void,
     object: sys::GDExtensionObjectPtr,
 ) -> sys::GDExtensionClassInstancePtr {
-    create_rust_part_for_existing_godot_part(T::__godot_user_init, object)
+    create_rust_part_for_existing_godot_part(T::__godot_user_init, object, None)
         .unwrap_or(std::ptr::null_mut())
 }
 
@@ -88,6 +100,7 @@ pub unsafe extern "C" fn recreate_null<T>(
 
 pub(crate) fn create_custom<T, F>(
     make_user_instance: F,
+    notify_postinitialize: bool,
 ) -> Result<sys::GDExtensionObjectPtr, PanicPayload>
 where
     T: GodotClass,
@@ -96,7 +109,16 @@ where
     let base_class_name = T::Base::class_name();
     let base_ptr = unsafe { interface_fn!(classdb_construct_object)(base_class_name.string_sys()) };
 
-    match create_rust_part_for_existing_godot_part(make_user_instance, base_ptr) {
+    #[cfg(before_api = "4.4")]
+    let postinit = None;
+    #[cfg(since_api = "4.4")]
+    let postinit = if notify_postinitialize {
+        Some(notify_postinit as unsafe fn(sys::GDExtensionObjectPtr))
+    } else {
+        None
+    };
+
+    match create_rust_part_for_existing_godot_part(make_user_instance, base_ptr, postinit) {
         Ok(_extension_ptr) => Ok(base_ptr),
         Err(payload) => {
             // Creation of extension object failed; we must now also destroy the base object to avoid leak.
@@ -118,6 +140,7 @@ where
 fn create_rust_part_for_existing_godot_part<T, F>(
     make_user_instance: F,
     base_ptr: sys::GDExtensionObjectPtr,
+    postinit: Option<unsafe fn(sys::GDExtensionObjectPtr)>,
 ) -> Result<sys::GDExtensionClassInstancePtr, PanicPayload>
 where
     T: GodotClass,
@@ -153,6 +176,10 @@ where
         );
     }
 
+    if let Some(postinit) = postinit {
+        unsafe { postinit(base_ptr) };
+    }
+
     // Mark initialization as complete, now that user constructor has finished.
     base_copy.mark_initialized();
 

godot-ffi/src/lib.rs

@@ -471,6 +471,17 @@ pub unsafe fn discover_main_thread() {
     }
 }
 
+/// # Safety
+/// `class_name` is assumed to be valid.
+pub unsafe fn classdb_construct_object(
+    class_name: GDExtensionConstStringNamePtr,
+) -> GDExtensionObjectPtr {
+    #[cfg(before_api = "4.4")]
+    return interface_fn!(classdb_construct_object)(class_name);
+    #[cfg(since_api = "4.4")]
+    return interface_fn!(classdb_construct_object2)(class_name);
+}
+
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 // Macros to access low-level function bindings
 

itest/rust/src/object_tests/base_init_test.rs

@@ -7,8 +7,10 @@
 
 use godot::builtin::real_consts::FRAC_PI_3;
 use godot::builtin::Vector2;
+use godot::classes::notify::ObjectNotification;
 use godot::classes::{ClassDb, RefCounted};
 use godot::obj::{Gd, InstanceId, NewAlloc, NewGd, WithBaseField};
+use godot::prelude::*;
 use godot::task::TaskHandle;
 
 use crate::framework::{expect_panic, itest, next_frame};
@@ -168,3 +170,27 @@ fn base_init_to_gd() {
         });
     });
 }
+
+#[derive(GodotClass)]
+#[class(init)]
+struct RefcPostinit {
+    pub base: Base<RefCounted>,
+}
+
+#[godot_api]
+impl IRefCounted for RefcPostinit {
+    fn on_notification(&mut self, what: ObjectNotification) {
+        if what == ObjectNotification::POSTINITIALIZE {
+            self.base
+                .to_init_gd()
+                .set_meta("meta", &"postinited".to_variant());
+        }
+    }
+}
+
+#[cfg(since_api = "4.4")]
+#[itest]
+fn base_postinit_refcounted() {
+    let obj = RefcPostinit::new_gd();
+    assert_eq!(obj.get_meta("meta"), "postinited".to_variant())
+}

itest/rust/src/object_tests/virtual_methods_test.rs

@@ -520,6 +520,8 @@ fn test_notifications() {
     assert_eq!(
         obj.bind().sequence,
         vec![
+            #[cfg(since_api = "4.4")]
+            ReceivedEvent::Notification(NodeNotification::POSTINITIALIZE),
             ReceivedEvent::Notification(NodeNotification::UNPAUSED),
             ReceivedEvent::Notification(NodeNotification::EDITOR_POST_SAVE),
             ReceivedEvent::Ready,