Update postinit handling

Author: beicause

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

@@ -325,7 +325,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

@@ -60,11 +60,7 @@ 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)
-    }
+    Gd::new_alloc_postinited()
 }
 
 pub(crate) fn ensure_object_alive(

godot-core/src/obj/bounds.rs

@@ -389,11 +389,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)
-        }
+        Gd::new_alloc_postinited()
     }
 }
 

godot-core/src/obj/gd.rs

@@ -560,6 +560,24 @@ impl<T: GodotClass> Gd<T> {
         // Do not increment ref-count; assumed to be return value from FFI.
         sys::ptr_then(object_ptr, |ptr| Gd::from_obj_sys_weak(ptr))
     }
+
+    pub(crate) fn new_alloc_postinited() -> Self {
+        #[cfg(before_api = "4.4")]
+        unsafe {
+            let object_ptr = sys::classdb_construct_object(T::class_name().string_sys());
+            Gd::from_obj_sys(object_ptr)
+        }
+        #[cfg(since_api = "4.4")]
+        unsafe {
+            let object_ptr =
+                sys::classdb_construct_object_no_postinit(T::class_name().string_sys());
+            let obj = Gd::<T>::from_obj_sys(object_ptr);
+            obj.clone()
+                .upcast_object()
+                .notify(crate::classes::notify::ObjectNotification::POSTINITIALIZE);
+            Gd::from_obj_sys(object_ptr)
+        }
+    }
 }
 
 /// _The methods in this impl block are only available for objects `T` that are manually managed,

godot-core/src/registry/callbacks.rs

@@ -33,7 +33,14 @@ 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())
+    if let Ok(object_ptr) = create_custom(T::__godot_user_init) {
+        let mut obj = Gd::<T>::from_obj_sys_weak(object_ptr).upcast_object();
+        obj.notify(crate::classes::notify::ObjectNotification::POSTINITIALIZE);
+        std::mem::forget(obj);
+        object_ptr
+    } else {
+        std::ptr::null_mut()
+    }
 }
 
 #[cfg(before_api = "4.4")]
@@ -92,7 +99,11 @@ where
     F: FnOnce(Base<T::Base>) -> T,
 {
     let base_class_name = T::Base::class_name();
-    let base_ptr = unsafe { interface_fn!(classdb_construct_object)(base_class_name.string_sys()) };
+    #[cfg(before_api = "4.4")]
+    let base_ptr = unsafe { sys::classdb_construct_object(base_class_name.string_sys()) };
+    #[cfg(since_api = "4.4")]
+    let base_ptr =
+        unsafe { sys::classdb_construct_object_no_postinit(base_class_name.string_sys()) };
 
     match create_rust_part_for_existing_godot_part(make_user_instance, base_ptr) {
         Ok(_extension_ptr) => Ok(base_ptr),

godot-ffi/src/lib.rs

@@ -440,6 +440,24 @@ pub fn is_main_thread() -> bool {
     std::thread::current().id() == main_thread_id()
 }
 
+/// # Safety
+/// `class_name` is assumed to be valid.
+#[cfg(before_api = "4.4")]
+pub unsafe fn classdb_construct_object(
+    class_name: GDExtensionConstStringNamePtr,
+) -> GDExtensionObjectPtr {
+    interface_fn!(classdb_construct_object)(class_name)
+}
+
+/// # Safety
+/// `class_name` is assumed to be valid.
+#[cfg(since_api = "4.4")]
+pub unsafe fn classdb_construct_object_no_postinit(
+    class_name: GDExtensionConstStringNamePtr,
+) -> GDExtensionObjectPtr {
+    interface_fn!(classdb_construct_object2)(class_name)
+}
+
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 // Macros to access low-level function bindings
 

itest/rust/src/engine_tests/node_test.rs

@@ -8,9 +8,11 @@
 use std::str::FromStr;
 
 use godot::builtin::{vslice, NodePath};
+use godot::classes::notify::NodeNotification;
 use godot::classes::{Node, Node3D, PackedScene, SceneTree};
 use godot::global;
 use godot::obj::{NewAlloc, NewGd};
+use godot::prelude::*;
 
 use crate::framework::{itest, TestContext};
 
@@ -92,3 +94,46 @@ fn node_call_group(ctx: &TestContext) {
     node.add_to_group("group");
     tree.call_group("group", "set_name", vslice!["name"]);
 }
+
+#[derive(GodotClass, Debug)]
+#[class(base=Node)]
+struct NodeChild {
+    child: Gd<Node>,
+    notifications: Vec<NodeNotification>,
+}
+
+#[godot_api]
+impl INode for NodeChild {
+    fn init(_: Base<Node>) -> Self {
+        let child = Node::new_alloc();
+        Self {
+            child,
+            notifications: vec![],
+        }
+    }
+
+    fn on_notification(&mut self, what: NodeNotification) {
+        match what {
+            NodeNotification::READY => self.notifications.push(NodeNotification::READY),
+            NodeNotification::PARENTED => self.notifications.push(NodeNotification::PARENTED),
+            NodeNotification::POSTINITIALIZE => {
+                self.notifications.push(NodeNotification::POSTINITIALIZE)
+            }
+            _ => {}
+        };
+    }
+}
+
+// https://github.com/godotengine/godot/issues/91023
+#[cfg(since_api = "4.4")]
+#[itest]
+fn node_add_child_in_init() {
+    let node = NodeChild::new_alloc();
+    let dup: Gd<NodeChild> = node.duplicate().unwrap().cast();
+    assert_eq!(
+        dup.bind().notifications,
+        vec![NodeNotification::POSTINITIALIZE]
+    );
+    node.free();
+    dup.free();
+}

itest/rust/src/object_tests/virtual_methods_test.rs

@@ -517,6 +517,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,