Impl Debug for RawGd<T> doesn't instantiate a new Gd<T>

Avoids side effects on Gd creation + needless delegation to RawGd.

Author: Bromeon

godot-core/src/classes/class_runtime.rs

@@ -13,7 +13,7 @@ use crate::classes::{ClassDb, Object};
 use crate::meta::CallContext;
 #[cfg(debug_assertions)]
 use crate::meta::ClassName;
-use crate::obj::{bounds, Bounds, Gd, GodotClass, InstanceId};
+use crate::obj::{bounds, Bounds, Gd, GodotClass, InstanceId, RawGd};
 use crate::sys;
 
 pub(crate) fn debug_string<T: GodotClass>(
@@ -23,12 +23,32 @@ pub(crate) fn debug_string<T: GodotClass>(
 ) -> std::fmt::Result {
     if let Some(id) = obj.instance_id_or_none() {
         let class: StringName = obj.dynamic_class_string();
-        write!(f, "{ty} {{ id: {id}, class: {class} }}")
+        f.debug_struct(ty)
+            .field("id", &id)
+            .field("class", &class)
+            .finish()
     } else {
         write!(f, "{ty} {{ freed obj }}")
     }
 }
 
+pub(crate) fn debug_string_nullable<T: GodotClass>(
+    obj: &RawGd<T>,
+    f: &mut std::fmt::Formatter<'_>,
+    ty: &str,
+) -> std::fmt::Result {
+    if obj.is_null() {
+        write!(f, "{ty} {{ null }}")
+    } else {
+        // Unsafety introduced here to avoid creating a new Gd<T> (which can have all sorts of side effects, logs, refcounts etc.)
+        // *and* pushing down all high-level Gd<T> functions to RawGd<T> as pure delegates.
+
+        // SAFETY: layout of Gd<T> is currently equivalent to RawGd<T>.
+        let obj: &Gd<T> = unsafe { std::mem::transmute::<&RawGd<T>, &Gd<T>>(obj) };
+        debug_string(obj, f, ty)
+    }
+}
+
 pub(crate) fn debug_string_with_trait<T: GodotClass>(
     obj: &Gd<T>,
     f: &mut std::fmt::Formatter<'_>,
@@ -37,7 +57,11 @@ pub(crate) fn debug_string_with_trait<T: GodotClass>(
 ) -> std::fmt::Result {
     if let Some(id) = obj.instance_id_or_none() {
         let class: StringName = obj.dynamic_class_string();
-        write!(f, "{ty} {{ id: {id}, class: {class}, trait: {trt} }}")
+        f.debug_struct(ty)
+            .field("id", &id)
+            .field("class", &class)
+            .field("trait", &trt)
+            .finish()
     } else {
         write!(f, "{ty} {{ freed obj }}")
     }
@@ -83,7 +107,7 @@ pub(crate) fn ensure_object_alive(
     // namely in PR https://github.com/godotengine/godot/pull/36189. Double-check to make sure.
     assert_eq!(
         new_object_ptr, old_object_ptr,
-        "{call_ctx}: instance ID {instance_id} points to a stale, reused object. Please report this to gdext maintainers."
+        "{call_ctx}: instance ID {instance_id} points to a stale, reused object. Please report this to godot-rust maintainers."
     );
 }
 

godot-core/src/obj/raw_gd.rs

@@ -95,8 +95,7 @@ impl<T: GodotClass> RawGd<T> {
 
     /// Returns `true` if the object is null.
     ///
-    /// This does not check if the object is dead, for that use
-    /// [`instance_id_or_none()`](Self::instance_id_or_none).
+    /// This does not check if the object is dead. For that, use [`is_instance_valid()`](Self::is_instance_valid).
     pub(crate) fn is_null(&self) -> bool {
         self.obj.is_null() || self.cached_rtti.is_none()
     }
@@ -689,12 +688,7 @@ impl<T: GodotClass> Clone for RawGd<T> {
 
 impl<T: GodotClass> fmt::Debug for RawGd<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        if self.is_null() {
-            return write!(f, "{} {{ null obj }}", std::any::type_name::<T>());
-        }
-
-        let gd = super::Gd::from_ffi(self.clone());
-        write!(f, "{gd:?}")
+        classes::debug_string_nullable(self, f, "RawGd")
     }
 }