Reduce code duplication in Storage

Bromeon · Bromeon · commit 6d8843076b3e · 2025-03-23T14:34:26.000+01:00
diff --git a/godot-core/src/registry/class.rs b/godot-core/src/registry/class.rs
@@ -216,9 +216,13 @@ pub fn auto_register_classes(init_level: InitLevel) {
     // but it is much slower and doesn't guarantee that all the dependent classes will be already loaded in most cases.
     register_classes_and_dyn_traits(&mut map, init_level);
 
-    // actually register all the classes
+    // Actually register all the classes.
     for info in map.into_values() {
+        #[cfg(feature = "debug-log")]
+        let class_name = info.class_name;
+
         register_class_raw(info);
+
         out!("Class {class_name} loaded.");
     }
 
diff --git a/godot-core/src/storage/instance_storage.rs b/godot-core/src/storage/instance_storage.rs
@@ -4,6 +4,7 @@
  * 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_ffi as sys;
 use std::cell::Cell;
 use std::ptr;
diff --git a/godot-core/src/storage/mod.rs b/godot-core/src/storage/mod.rs
@@ -11,4 +11,71 @@ mod multi_threaded;
 #[cfg_attr(feature = "experimental-threads", allow(dead_code))]
 mod single_threaded;
 
+use godot_ffi::out;
 pub use instance_storage::*;
+use std::any::type_name;
+
+// ----------------------------------------------------------------------------------------------------------------------------------------------
+// Shared code for submodules
+
+fn bind_failed<T>(err: Box<dyn std::error::Error>) -> ! {
+    let ty = type_name::<T>();
+    panic!(
+        "Gd<T>::bind() failed, already bound; T = {ty}.\n  \
+        Make sure to use `self.base_mut()` or `self.base()` instead of `self.to_gd()` when possible.\n  \
+        Details: {err}."
+    )
+}
+
+fn bind_mut_failed<T>(err: Box<dyn std::error::Error>) -> ! {
+    let ty = type_name::<T>();
+    panic!(
+        "Gd<T>::bind_mut() failed, already bound; T = {ty}.\n  \
+        Make sure to use `self.base_mut()` instead of `self.to_gd()` when possible.\n  \
+        Details: {err}."
+    )
+}
+
+fn bug_inaccessible<T>(err: Box<dyn std::error::Error>) -> ! {
+    // We should never hit this, except maybe in extreme cases like having more than
+    // `usize::MAX` borrows.
+    let ty = type_name::<T>();
+    panic!(
+        "`base_mut()` failed for type T = {ty}.\n  \
+        This is most likely a bug, please report it.\n  \
+        Details: {err}."
+    )
+}
+
+fn log_construct<T>() {
+    out!(
+        "    Storage::construct             <{ty}>",
+        ty = type_name::<T>()
+    );
+}
+
+fn log_inc_ref<T: StorageRefCounted>(storage: &T) {
+    out!(
+        "    Storage::on_inc_ref (rc={rc})     <{ty}> -- {base:?}",
+        rc = T::godot_ref_count(storage),
+        base = storage.base(),
+        ty = type_name::<T>(),
+    );
+}
+
+fn log_dec_ref<T: StorageRefCounted>(storage: &T) {
+    out!(
+        "  | Storage::on_dec_ref (rc={rc})     <{ty}> -- {base:?}",
+        rc = T::godot_ref_count(storage),
+        base = storage.base(),
+        ty = type_name::<T>(),
+    );
+}
+
+fn log_drop<T: StorageRefCounted>(storage: &T) {
+    out!(
+        "    Storage::drop (rc={rc})           <{base:?}>",
+        rc = storage.godot_ref_count(),
+        base = storage.base(),
+    );
+}
diff --git a/godot-core/src/storage/multi_threaded.rs b/godot-core/src/storage/multi_threaded.rs
@@ -5,7 +5,6 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
-use std::any::type_name;
 use std::sync::atomic::{AtomicU32, Ordering};
 
 #[cfg(not(feature = "experimental-threads"))]
@@ -15,7 +14,6 @@ use godot_cell::panicking::{GdCell, InaccessibleGuard, MutGuard, RefGuard};
 use godot_cell::blocking::{GdCell, InaccessibleGuard, MutGuard, RefGuard};
 
 use crate::obj::{Base, GodotClass};
-use crate::out;
 use crate::storage::{AtomicLifecycle, Lifecycle, Storage, StorageRefCounted};
 
 pub struct InstanceStorage<T: GodotClass> {
@@ -42,7 +40,8 @@ unsafe impl<T: GodotClass> Storage for InstanceStorage<T> {
         user_instance: Self::Instance,
         base: Base<<Self::Instance as GodotClass>::Base>,
     ) -> Self {
-        out!("    Storage::construct             <{}>", type_name::<T>());
+        super::log_construct::<T>();
+
         Self {
             user_instance: GdCell::new(user_instance),
             base,
@@ -60,29 +59,15 @@ unsafe impl<T: GodotClass> Storage for InstanceStorage<T> {
     }
 
     fn get(&self) -> RefGuard<'_, T> {
-        self.user_instance.borrow().unwrap_or_else(|err| {
-            panic!(
-                "\
-                    Gd<T>::bind() failed, already bound; T = {}.\n  \
-                    Make sure to use `self.base_mut()` or `self.base()` instead of `self.to_gd()` when possible.\n  \
-                    Details: {err}.\
-                ",
-                type_name::<T>()
-            )
-        })
+        self.user_instance
+            .borrow()
+            .unwrap_or_else(|e| super::bind_failed::<T>(e))
     }
 
     fn get_mut(&self) -> MutGuard<'_, T> {
-        self.user_instance.borrow_mut().unwrap_or_else(|err| {
-            panic!(
-                "\
-                    Gd<T>::bind_mut() failed, already bound; T = {}.\n  \
-                    Make sure to use `self.base_mut()` instead of `self.to_gd()` when possible.\n  \
-                    Details: {err}.\
-                ",
-                type_name::<T>()
-            )
-        })
+        self.user_instance
+            .borrow_mut()
+            .unwrap_or_else(|e| super::bind_mut_failed::<T>(e))
     }
 
     fn get_inaccessible<'a: 'b, 'b>(
@@ -91,18 +76,7 @@ unsafe impl<T: GodotClass> Storage for InstanceStorage<T> {
     ) -> InaccessibleGuard<'b, T> {
         self.user_instance
             .make_inaccessible(value)
-            .unwrap_or_else(|err| {
-                // We should never hit this, except maybe in extreme cases like having more than
-                // `usize::MAX` borrows.
-                panic!(
-                    "\
-                        `base_mut()` failed for type T = {}.\n  \
-                        This is most likely a bug, please report it.\n  \
-                        Details: {err}.\
-                    ",
-                    type_name::<T>()
-                )
-            })
+            .unwrap_or_else(|e| super::bug_inaccessible::<T>(e))
     }
 
     fn get_lifecycle(&self) -> Lifecycle {
@@ -121,29 +95,19 @@ impl<T: GodotClass> StorageRefCounted for InstanceStorage<T> {
 
     fn on_inc_ref(&self) {
         self.godot_ref_count.fetch_add(1, Ordering::Relaxed);
-        out!(
-            "    Storage::on_inc_ref (rc={})     <{:?}>",
-            self.godot_ref_count(),
-            self.base,
-        );
+
+        super::log_inc_ref(self);
     }
 
     fn on_dec_ref(&self) {
         self.godot_ref_count.fetch_sub(1, Ordering::Relaxed);
-        out!(
-            "  | Storage::on_dec_ref (rc={})     <{:?}>",
-            self.godot_ref_count(),
-            self.base,
-        );
+
+        super::log_dec_ref(self);
     }
 }
 
 impl<T: GodotClass> Drop for InstanceStorage<T> {
     fn drop(&mut self) {
-        out!(
-            "    Storage::drop (rc={})           <{:?}>",
-            self.godot_ref_count(),
-            self.base(),
-        );
+        super::log_drop(self);
     }
 }
diff --git a/godot-core/src/storage/single_threaded.rs b/godot-core/src/storage/single_threaded.rs
@@ -5,7 +5,6 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
-use std::any::type_name;
 use std::cell;
 
 #[cfg(not(feature = "experimental-threads"))]
@@ -15,7 +14,7 @@ use godot_cell::panicking::{GdCell, InaccessibleGuard, MutGuard, RefGuard};
 use godot_cell::blocking::{GdCell, InaccessibleGuard, MutGuard, RefGuard};
 
 use crate::obj::{Base, GodotClass};
-use crate::out;
+use crate::storage::borrow_info::DebugBorrowTracker;
 use crate::storage::{Lifecycle, Storage, StorageRefCounted};
 
 pub struct InstanceStorage<T: GodotClass> {
@@ -42,7 +41,8 @@ unsafe impl<T: GodotClass> Storage for InstanceStorage<T> {
         user_instance: Self::Instance,
         base: Base<<Self::Instance as GodotClass>::Base>,
     ) -> Self {
-        out!("    Storage::construct             <{}>", type_name::<T>());
+        super::log_construct::<T>();
+
         Self {
             user_instance: GdCell::new(user_instance),
             base,
@@ -60,49 +60,24 @@ unsafe impl<T: GodotClass> Storage for InstanceStorage<T> {
     }
 
     fn get(&self) -> RefGuard<'_, T> {
-        self.user_instance.borrow().unwrap_or_else(|err| {
-            panic!(
-                "\
-                    Gd<T>::bind() failed, already bound; T = {}.\n  \
-                    Make sure to use `self.base_mut()` or `self.base()` instead of `self.to_gd()` when possible.\n  \
-                    Details: {err}.\
-                ",
-                type_name::<T>()
-            )
-        })
+        self.user_instance
+            .borrow()
+            .unwrap_or_else(|e| super::bind_failed::<T>(e))
     }
 
     fn get_mut(&self) -> MutGuard<'_, T> {
-        self.user_instance.borrow_mut().unwrap_or_else(|err| {
-            panic!(
-                "\
-                    Gd<T>::bind_mut() failed, already bound; T = {}.\n  \
-                    Make sure to use `self.base_mut()` instead of `self.to_gd()` when possible.\n  \
-                    Details: {err}.\
-                ",
-                type_name::<T>()
-            )
-        })
+        self.user_instance
+            .borrow_mut()
+            .unwrap_or_else(|e| super::bind_mut_failed::<T>(e))
     }
 
-    fn get_inaccessible<'a: 'b, 'b>(
-        &'a self,
-        value: &'b mut Self::Instance,
-    ) -> InaccessibleGuard<'b, T> {
+    fn get_inaccessible<'stor: 'inst, 'inst>(
+        &'stor self,
+        value: &'inst mut Self::Instance,
+    ) -> InaccessibleGuard<'inst, T> {
         self.user_instance
             .make_inaccessible(value)
-            .unwrap_or_else(|err| {
-                // We should never hit this, except maybe in extreme cases like having more than
-                // `usize::MAX` borrows.
-                panic!(
-                    "\
-                        `base_mut()` failed for type T = {}.\n  \
-                        This is most likely a bug, please report it.\n  \
-                        Details: {err}.\
-                    ",
-                    type_name::<T>()
-                )
-            })
+            .unwrap_or_else(|e| super::bug_inaccessible::<T>(e))
     }
 
     fn get_lifecycle(&self) -> Lifecycle {
@@ -123,33 +98,19 @@ impl<T: GodotClass> StorageRefCounted for InstanceStorage<T> {
         let refc = self.godot_ref_count.get() + 1;
         self.godot_ref_count.set(refc);
 
-        out!(
-            "    Storage::on_inc_ref (rc={})     <{}>", // -- {:?}",
-            refc,
-            type_name::<T>(),
-            //self.user_instance
-        );
+        super::log_inc_ref(self);
     }
 
     fn on_dec_ref(&self) {
         let refc = self.godot_ref_count.get() - 1;
         self.godot_ref_count.set(refc);
 
-        out!(
-            "  | Storage::on_dec_ref (rc={})     <{}>", // -- {:?}",
-            refc,
-            type_name::<T>(),
-            //self.user_instance
-        );
+        super::log_dec_ref(self);
     }
 }
 
 impl<T: GodotClass> Drop for InstanceStorage<T> {
     fn drop(&mut self) {
-        out!(
-            "    Storage::drop (rc={})           <{:?}>",
-            self.godot_ref_count(),
-            self.base(),
-        );
+        super::log_drop(self);
     }
 }
