base() + base_mut() now use weak references

Author: Bromeon

godot-core/src/obj/base.rs

@@ -314,7 +314,8 @@ impl<T: GodotClass> Base<T> {
             "to_script_gd() can only be called on script-context Base objects"
         );
 
-        (*self.obj).clone()
+        // SAFETY: ScriptBase{Ref,Mut} also drop weakly.
+        unsafe { (*self.obj).clone_weak() }
     }
 
     /// Returns `true` if this `Base<T>` is currently in the initializing state.
@@ -334,6 +335,22 @@ impl<T: GodotClass> Base<T> {
 
         (*self.obj).clone()
     }
+
+    /// Returns a weak [`Gd`] referencing the base object, assuming the derived object is fully constructed.
+    ///
+    /// Unlike `__constructed_gd()`, this does not increment the reference count for ref-counted `T`s.
+    /// The returned weak reference is safe to use only as long as the associated instance remains alive.
+    #[doc(hidden)]
+    pub fn __constructed_gd_weak(&self) -> Gd<T> {
+        #[cfg(debug_assertions)] // debug_assert! still checks existence of symbols.
+        assert!(
+            !self.is_initializing(),
+            "WithBaseField::base(), base_mut() can only be called on fully-constructed objects, after I*::init() or Gd::from_init_fn()"
+        );
+
+        // Create weak reference from the same object pointer without cloning (incrementing refcount).
+        unsafe { Gd::from_obj_sys_weak(self.obj.obj_sys()) }
+    }
 }
 
 impl<T: GodotClass> Debug for Base<T> {

godot-core/src/obj/gd.rs

@@ -335,6 +335,15 @@ impl<T: GodotClass> Gd<T> {
         Some(rc.map(|i| i as usize))
     }
 
+    /// Create a non-owning pointer from this.
+    ///
+    /// # Safety
+    /// Must be destroyed with [`drop_weak()`][Self::drop_weak]; regular `Drop` will cause use-after-free.
+    pub(crate) unsafe fn clone_weak(&self) -> Self {
+        // SAFETY: delegated to caller.
+        unsafe { Gd::from_obj_sys_weak(self.obj_sys()) }
+    }
+
     /// Drop without decrementing ref-counter.
     ///
     /// Needed in situations where the instance should effectively be forgotten, but without leaking other associated data.

godot-core/src/obj/guards.rs

@@ -199,24 +199,32 @@ macro_rules! make_base_ref {
         #[doc = concat!("This can be used to call methods on the base object of a ", $object_name, " that takes `&self` as the receiver.\n\n")]
         #[doc = concat!("See [`", stringify!($doc_type), "::base()`](", stringify!($doc_path), "::base()) for usage.")]
         pub struct $ident<'a, T: $bound> {
-            gd: Gd<T::Base>,
+            // Weak reference to the base object. Safe because 'a lifetime keeps the object (strong ref) alive.
+            // Option because Gd::drop_weak() takes ownership, thus can't use ManuallyDrop.
+            weak_gd: Option<Gd<T::Base>>,
             _instance: &'a T,
         }
 
         impl<'a, T: $bound> $ident<'a, T> {
-            pub(crate) fn new(gd: Gd<T::Base>, instance: &'a T) -> Self {
+            pub(crate) fn new(weak_gd: Gd<T::Base>, instance: &'a T) -> Self {
                 Self {
-                    gd,
+                    weak_gd: Some(weak_gd),
                     _instance: instance,
                 }
             }
         }
 
+        impl<'a, T: $bound> Drop for $ident<'a, T> {
+            fn drop(&mut self) {
+                self.weak_gd.take().unwrap().drop_weak();
+            }
+        }
+
         impl<T: $bound> Deref for $ident<'_, T> {
             type Target = Gd<T::Base>;
 
             fn deref(&self) -> &Gd<T::Base> {
-                &self.gd
+                self.weak_gd.as_ref().unwrap()
             }
         }
     };
@@ -232,33 +240,41 @@ macro_rules! make_base_mut {
         ///
         #[doc = concat!("See [`", stringify!($doc_type), "::base_mut()`](", stringify!($doc_path), "::base_mut()) for usage.\n")]
         pub struct $ident<'a, T: $bound> {
-            gd: Gd<T::Base>,
+            // Weak reference to the base object. Safe because 'a lifetime keeps the object (strong ref) alive.
+            // Option because Gd::drop_weak() takes ownership, thus can't use ManuallyDrop.
+            weak_gd: Option<Gd<T::Base>>,
             _inaccessible_guard: InaccessibleGuard<'a, T>,
         }
 
         impl<'a, T: $bound> $ident<'a, T> {
             pub(crate) fn new(
-                gd: Gd<T::Base>,
+                weak_gd: Gd<T::Base>,
                 inaccessible_guard: InaccessibleGuard<'a, T>,
             ) -> Self {
                 Self {
-                    gd,
+                    weak_gd: Some(weak_gd),
                     _inaccessible_guard: inaccessible_guard,
                 }
             }
         }
 
+        impl<'a, T: $bound> Drop for $ident<'a, T> {
+            fn drop(&mut self) {
+                self.weak_gd.take().unwrap().drop_weak();
+            }
+        }
+
         impl<T: $bound> Deref for $ident<'_, T> {
             type Target = Gd<T::Base>;
 
             fn deref(&self) -> &Gd<T::Base> {
-                &self.gd
+                self.weak_gd.as_ref().unwrap()
             }
         }
 
         impl<T: $bound> DerefMut for $ident<'_, T> {
             fn deref_mut(&mut self) -> &mut Gd<T::Base> {
-                &mut self.gd
+                self.weak_gd.as_mut().unwrap()
             }
         }
     };

godot-core/src/obj/traits.rs

@@ -422,9 +422,9 @@ pub trait WithBaseField: GodotClass + Bounds<Declarer = bounds::DeclUser> {
     ///
     /// For this, use [`base_mut()`](WithBaseField::base_mut()) instead.
     fn base(&self) -> BaseRef<'_, Self> {
-        let gd = self.base_field().__constructed_gd();
+        let weak_gd = self.base_field().__constructed_gd_weak();
 
-        BaseRef::new(gd, self)
+        BaseRef::new(weak_gd, self)
     }
 
     /// Returns a mutable reference suitable for calling engine methods on this object.
@@ -493,7 +493,7 @@ pub trait WithBaseField: GodotClass + Bounds<Declarer = bounds::DeclUser> {
     /// ```
     #[allow(clippy::let_unit_value)]
     fn base_mut(&mut self) -> BaseMut<'_, Self> {
-        let base_gd = self.base_field().__constructed_gd();
+        let weak_gd = self.base_field().__constructed_gd_weak();
 
         let gd = self.to_gd();
         // SAFETY:
@@ -514,7 +514,7 @@ pub trait WithBaseField: GodotClass + Bounds<Declarer = bounds::DeclUser> {
 
         let guard = storage.get_inaccessible(self);
 
-        BaseMut::new(base_gd, guard)
+        BaseMut::new(weak_gd, guard)
     }
 }