Remove handling of "surplus strong ref" in InstanceStorage

Currently no purpose.

Author: Bromeon

godot-core/src/obj/base.rs

@@ -228,7 +228,7 @@ impl<T: GodotClass> Base<T> {
     }
 
     /// Finalizes the initialization of this `Base<T>` and returns whether
-    pub(crate) fn mark_initialized(&mut self) -> bool {
+    pub(crate) fn mark_initialized(&mut self) {
         #[cfg(debug_assertions)]
         {
             assert_eq!(
@@ -240,7 +240,7 @@ impl<T: GodotClass> Base<T> {
             self.init_state.set(InitState::ObjectInitialized);
         }
 
-        self.extra_strong_ref.borrow().is_some()
+        // May return whether there is a "surplus" strong ref in the future, as self.extra_strong_ref.borrow().is_some().
     }
 
     /// Returns a [`Gd`] referencing the base object, assuming the derived object is fully constructed.

godot-core/src/registry/callbacks.rs

@@ -154,11 +154,7 @@ where
     }
 
     // Mark initialization as complete, now that user constructor has finished.
-    if base_copy.mark_initialized() {
-        // If an extra RefCounted reference was handed out, notify storage about it, so it can unreference later.
-        let instance_ref = unsafe { &*instance_rust_ptr };
-        instance_ref.mark_surplus_ref();
-    }
+    base_copy.mark_initialized();
 
     // No std::mem::forget(base_copy) here, since Base may stores other fields that need deallocation.
     Ok(instance_ptr)

godot-core/src/storage/instance_storage.rs

@@ -139,13 +139,6 @@ pub unsafe trait Storage {
         log_pre_drop(self);
     }
 
-    /// For ref-counted objects, marks as owning a surplus reference.
-    ///
-    /// Needed when a `Base<T>` hands out extra `Gd<T>` pointers during `init()`, which then requires upgrading the `Base`
-    /// weak pointer to a strong one. To compensate, this bool flag will skip the first `inc_ref()` call, which is typically
-    /// object construction.
-    fn mark_surplus_ref(&self);
-
     /*#[inline(always)]
     fn destroyed_by_godot(&self) -> bool {
         out!(

godot-core/src/storage/multi_threaded.rs

@@ -5,8 +5,6 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
-use std::sync::atomic::{AtomicBool, Ordering};
-
 #[cfg(feature = "experimental-threads")]
 use godot_cell::blocking::{GdCell, InaccessibleGuard, MutGuard, RefGuard};
 #[cfg(not(feature = "experimental-threads"))]
@@ -21,7 +19,6 @@ pub struct InstanceStorage<T: GodotClass> {
 
     // Declared after `user_instance`, is dropped last
     pub(super) lifecycle: AtomicLifecycle,
-    has_surplus_ref: AtomicBool,
 
     // No-op in Release mode.
     borrow_tracker: DebugBorrowTracker,
@@ -48,7 +45,6 @@ unsafe impl<T: GodotClass> Storage for InstanceStorage<T> {
             user_instance: GdCell::new(user_instance),
             base,
             lifecycle: AtomicLifecycle::new(Lifecycle::Alive),
-            has_surplus_ref: AtomicBool::new(false),
             borrow_tracker: DebugBorrowTracker::new(),
         }
     }
@@ -57,10 +53,6 @@ unsafe impl<T: GodotClass> Storage for InstanceStorage<T> {
         self.user_instance.is_currently_bound()
     }
 
-    fn mark_surplus_ref(&self) {
-        self.has_surplus_ref.store(true, Ordering::Relaxed);
-    }
-
     fn base(&self) -> &Base<<Self::Instance as GodotClass>::Base> {
         &self.base
     }

godot-core/src/storage/single_threaded.rs

@@ -21,7 +21,6 @@ pub struct InstanceStorage<T: GodotClass> {
 
     // Declared after `user_instance`, is dropped last.
     pub(super) lifecycle: cell::Cell<Lifecycle>,
-    has_surplus_ref: cell::Cell<bool>,
 
     // No-op in Release mode.
     borrow_tracker: DebugBorrowTracker,
@@ -48,7 +47,6 @@ unsafe impl<T: GodotClass> Storage for InstanceStorage<T> {
             user_instance: GdCell::new(user_instance),
             base,
             lifecycle: cell::Cell::new(Lifecycle::Alive),
-            has_surplus_ref: cell::Cell::new(false),
             borrow_tracker: DebugBorrowTracker::new(),
         }
     }
@@ -57,10 +55,6 @@ unsafe impl<T: GodotClass> Storage for InstanceStorage<T> {
         self.user_instance.is_currently_bound()
     }
 
-    fn mark_surplus_ref(&self) {
-        self.has_surplus_ref.set(true);
-    }
-
     fn base(&self) -> &Base<<Self::Instance as GodotClass>::Base> {
         &self.base
     }
@@ -105,25 +99,18 @@ unsafe impl<T: GodotClass> Storage for InstanceStorage<T> {
 
 impl<T: GodotClass> StorageRefCounted for InstanceStorage<T> {
     fn on_inc_ref(&self) {
-        if self.has_surplus_ref.get() {
-            self.has_surplus_ref.set(false);
-
-            return; // If we have surplus references, we don't increment the ref count.
-        }
+        // Note: on_inc_ref() and on_dec_ref() do not track extra strong references from Base::to_init_gd().
+        // See https://github.com/godot-rust/gdext/pull/1273 for code that had it.
 
         super::log_inc_ref(self);
     }
 
     fn on_dec_ref(&self) {
-        // IMPORTANT: it is too late here to perform dec-ref operations on the Base (for "surplus" references).
+        // IMPORTANT: it is too late here to perform dec-ref operations on the Base (for "surplus" strong references).
         // This callback is only invoked in the C++ condition `if (rc_val <= 1 /* higher is not relevant */)` -- see Godot ref_counted.cpp.
         // The T <-> RefCounted hierarchical relation is usually already broken up at this point, and further dec-ref may bring the count
         // down to 0.
 
-        if self.has_surplus_ref.get() {
-            self.has_surplus_ref.set(false);
-        }
-
         super::log_dec_ref(self);
     }
 }