Add WeakGd

Author: beicause

godot-core/src/obj/base.rs

@@ -15,6 +15,7 @@ use std::mem::ManuallyDrop;
 use std::rc::Rc;
 
 use crate::builtin::{Callable, Variant};
+use crate::obj::weak_gd::WeakGd;
 use crate::obj::{bounds, Gd, GodotClass, InstanceId};
 use crate::{classes, sys};
 
@@ -166,6 +167,10 @@ impl<T: GodotClass> Base<T> {
         (*self.obj).clone()
     }
 
+    pub fn to_weak_gd(&self) -> WeakGd<T> {
+        WeakGd::from_base(self)
+    }
+
     /// Returns a [`Gd`] referencing the base object, for exclusive use during object initialization.
     ///
     /// Can be used during an initialization function [`I*::init()`][crate::classes::IObject::init] or [`Gd::from_init_fn()`].
@@ -328,6 +333,10 @@ impl<T: GodotClass> Base<T> {
 
         (*self.obj).clone()
     }
+
+    pub(crate) fn is_instance_valid(&self) -> bool {
+        self.obj.is_instance_valid()
+    }
 }
 
 impl<T: GodotClass> Debug for Base<T> {

godot-core/src/obj/casts.rs

@@ -47,13 +47,6 @@ impl<T: GodotClass, U: GodotClass> CastSuccess<T, U> {
         }
     }
 
-    /// Access shared reference to destination, without consuming object.
-    #[cfg(debug_assertions)]
-    pub fn as_dest_ref(&self) -> &RawGd<U> {
-        self.check_validity();
-        &self.dest
-    }
-
     /// Access exclusive reference to destination, without consuming object.
     pub fn as_dest_mut(&mut self) -> &mut RawGd<U> {
         self.check_validity();

godot-core/src/obj/mod.rs

@@ -22,6 +22,7 @@ mod on_editor;
 mod on_ready;
 mod raw_gd;
 mod traits;
+mod weak_gd;
 
 pub(crate) mod rtti;
 
@@ -35,6 +36,7 @@ pub use on_editor::*;
 pub use on_ready::*;
 pub use raw_gd::*;
 pub use traits::*;
+pub use weak_gd::*;
 
 pub mod bounds;
 pub mod script;

godot-core/src/obj/raw_gd.rs

@@ -358,27 +358,6 @@ impl<T: GodotClass> RawGd<T> {
         // Validation object identity.
         self.check_rtti("upcast_ref");
         debug_assert!(!self.is_null(), "cannot upcast null object refs");
-
-        // In Debug builds, go the long path via Godot FFI to verify the results are the same.
-        #[cfg(debug_assertions)]
-        {
-            // SAFETY: we forget the object below and do not leave the function before.
-            let ffi_dest = self.ffi_cast::<Base>().expect("failed FFI upcast");
-
-            // The ID check is not that expressive; we should do a complete comparison of the ObjectRtti, but currently the dynamic types can
-            // be different (see comment in ObjectRtti struct). This at least checks that the transmuted object is not complete garbage.
-            // We get direct_id from Self and not Base because the latter has no API with current bounds; but this equivalence is tested in Deref.
-            let direct_id = self.instance_id_unchecked().expect("direct_id null");
-            let ffi_id = ffi_dest
-                .as_dest_ref()
-                .instance_id_unchecked()
-                .expect("ffi_id null");
-
-            assert_eq!(
-                direct_id, ffi_id,
-                "upcast_ref: direct and FFI IDs differ. This is a bug, please report to godot-rust maintainers."
-            );
-        }
     }
 
     /// Verify that the object is non-null and alive. In Debug mode, additionally verify that it is of type `T` or derived.

godot-core/src/obj/weak_gd.rs

@@ -0,0 +1,134 @@
+/*
+ * 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 std::fmt::{Debug, Formatter, Result as FmtResult};
+use std::mem::ManuallyDrop;
+use std::ops::{Deref, DerefMut};
+
+use crate::classes;
+use crate::obj::{bounds, Base, Bounds, Gd, GdDerefTarget, GodotClass, Inherits, RawGd};
+
+/// Weak pointer to objects owned by the Godot engine.
+/// `WeakGd<T>` doesn't guarantee the validation of the object and can hold a dead object.
+/// For `RefCounted`, it doesn't affect the reference count, which means it doesn't decrease reference count when dropped and doesn't prevent the `RefCounted` from being released.
+/// Can be used during initialization [`I*::init()`][crate::classes::IObject::init] or [`Gd::from_init_fn()`], and deconstruction [Drop].
+///
+/// # Panics
+/// If the weak pointer is invalid when dereferencing to call a Godot method.
+pub struct WeakGd<T: GodotClass> {
+    gd: Option<ManuallyDrop<Gd<T>>>,
+}
+
+impl<T: GodotClass> WeakGd<T> {
+    fn from_raw_gd(val: &RawGd<T>) -> Self {
+        Self {
+            gd: if val.is_instance_valid() {
+                unsafe { Some(ManuallyDrop::new(Gd::from_obj_sys_weak(val.obj_sys()))) }
+            } else {
+                None
+            },
+        }
+    }
+
+    /// Create a weak pointer from a [Gd].
+    pub fn from_gd(val: &Gd<T>) -> Self {
+        Self::from_raw_gd(&val.raw)
+    }
+
+    /// Create a weak pointer from a [Base].
+    pub fn from_base(val: &Base<T>) -> Self {
+        Self {
+            gd: if val.is_instance_valid() {
+                unsafe { Some(ManuallyDrop::new(Gd::from_obj_sys_weak(val.obj_sys()))) }
+            } else {
+                None
+            },
+        }
+    }
+
+    fn ffi_cast<U: GodotClass>(self) -> Result<WeakGd<U>, Self> {
+        if !self.is_instance_valid() {
+            return Err(WeakGd { gd: None });
+        }
+        let WeakGd { gd } = self;
+        let mut gd = gd.unwrap();
+        let Gd { raw } = unsafe { ManuallyDrop::take(&mut gd) };
+        let cast = raw.ffi_cast::<U>();
+
+        let raw = match cast {
+            Ok(res) => Ok(ManuallyDrop::new(res.into_dest(raw))),
+            Err(_) => Err(ManuallyDrop::new(raw)),
+        };
+        raw.map(|v| WeakGd::from_raw_gd(&v))
+            .map_err(|e| WeakGd::from_raw_gd(&e))
+    }
+
+    /// **Downcast:** try to convert into a weak pointer to a derived class, fails if this weak pointer is invalid.
+    pub fn try_cast<Derived>(self) -> Result<WeakGd<Derived>, Self>
+    where
+        Derived: Inherits<T>,
+    {
+        self.ffi_cast()
+    }
+
+    /// **Upcast:** try to convert into a weak pointer to a base class, fails if this weak pointer is invalid.
+    pub fn try_upcast<Base>(self) -> Result<WeakGd<Base>, Self>
+    where
+        Base: GodotClass,
+        T: Inherits<Base>,
+    {
+        self.ffi_cast()
+    }
+
+    /// Checks if this weak pointer points to a live object.
+    pub fn is_instance_valid(&self) -> bool {
+        self.gd
+            .as_ref()
+            .map(|v| v.is_instance_valid())
+            .unwrap_or(false)
+    }
+}
+
+impl<T: GodotClass> Deref for WeakGd<T>
+where
+    GdDerefTarget<T>: Bounds<Declarer = bounds::DeclEngine>,
+{
+    type Target = GdDerefTarget<T>;
+
+    fn deref(&self) -> &Self::Target {
+        self.gd.as_ref().unwrap().deref()
+    }
+}
+
+impl<T: GodotClass> DerefMut for WeakGd<T>
+where
+    GdDerefTarget<T>: Bounds<Declarer = bounds::DeclEngine>,
+{
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.gd.as_mut().unwrap().deref_mut()
+    }
+}
+
+impl<T: GodotClass> Clone for WeakGd<T> {
+    fn clone(&self) -> Self {
+        if let Some(gd) = self.gd.as_ref() {
+            Self::from_gd(gd)
+        } else {
+            Self { gd: None }
+        }
+    }
+}
+
+impl<T: GodotClass> Debug for WeakGd<T> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
+        if self.is_instance_valid() {
+            classes::debug_string(self.gd.as_ref().unwrap(), f, "WeakGd")
+        } else {
+            write!(f, "WeakGd {{ null }}")
+        }
+    }
+}

itest/rust/src/object_tests/mod.rs

@@ -35,6 +35,7 @@ mod base_init_test;
 mod validate_property_test;
 mod virtual_methods_niche_test;
 mod virtual_methods_test;
+mod weak_gd_test;
 
 // Need to test this in the init level method.
 pub use init_level_test::initialize_init_level_test;

itest/rust/src/object_tests/weak_gd_test.rs

@@ -0,0 +1,38 @@
+/*
+ * 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::obj::WeakGd;
+use godot::prelude::*;
+
+use crate::framework::itest;
+
+#[derive(GodotClass, Debug)]
+#[class(base=RefCounted)]
+struct RefcBasedDrop {
+    pub base: Base<RefCounted>,
+}
+
+#[godot_api]
+impl IRefCounted for RefcBasedDrop {
+    fn init(base: Base<RefCounted>) -> Self {
+        let mut obj: WeakGd<RefcBasedDrop> = base.to_weak_gd().try_cast().unwrap();
+        obj.set_meta("meta", &"inited".to_variant());
+        Self { base }
+    }
+}
+
+impl Drop for RefcBasedDrop {
+    fn drop(&mut self) {
+        let obj = self.base.to_weak_gd();
+        assert_eq!(obj.get_meta("meta"), "inited".to_variant());
+    }
+}
+
+#[itest]
+fn weak_init_drop_refcounted() {
+    RefcBasedDrop::new_gd();
+}