Remove NotUniqueError, keep Gd::try_to_unique() simple

Implements IoError::source() for all paths.

Author: Bromeon

godot-core/src/meta/error/mod.rs

@@ -9,8 +9,6 @@
 
 mod call_error;
 mod convert_error;
-mod not_unique_error;
 
 pub use call_error::*;
 pub use convert_error::*;
-pub use not_unique_error::*;

godot-core/src/meta/error/not_unique_error.rs

@@ -561,31 +561,32 @@ where
 {
     /// Makes sure that `self` does not share references with other `Gd` instances.
     ///
-    /// If `self` is unique, i.e. its reference count is 1, then `Ok(self)` is returned.
-    ///
-    /// If `self` is shared or not reference-counted (`T=Object` pointing to a dynamic type that is manually managed),
-    /// then `Err((self, NotUniqueError))` is returned. You can thus reuse the original object (first element in the tuple).
+    /// Succeeds if the reference count is 1.
+    /// Otherwise, returns the shared object and its reference count.
     ///
     /// ## Example
     ///
     /// ```no_run
     /// use godot::prelude::*;
-    /// use godot::meta::error::NotUniqueError;
-    ///
-    /// let unique = RefCounted::new_gd();
-    /// assert!(unique.try_to_unique().is_ok());
     ///
-    /// let shared = RefCounted::new_gd();
-    /// let shared2 = shared.clone();
-    /// assert!(shared.try_to_unique().is_err());
+    /// let obj = RefCounted::new_gd();
+    /// match obj.try_to_unique() {
+    ///    Ok(unique_obj) => {
+    ///        // No other Gd<T> shares a reference with `unique_obj`.
+    ///    },
+    ///    Err((shared_obj, ref_count)) => {
+    ///        // `shared_obj` is the original object `obj`.
+    ///        // `ref_count` is the total number of references (including one held by `shared_obj`).
+    ///    }
+    /// }
     /// ```
-    pub fn try_to_unique(mut self) -> Result<Self, (Self, NotUniqueError)> {
+    pub fn try_to_unique(self) -> Result<Self, (Self, usize)> {
         use crate::obj::bounds::DynMemory as _;
 
         match <T as Bounds>::DynMemory::get_ref_count(&self.raw) {
             Some(1) => Ok(self),
-            Some(ref_count) => Err((self, NotUniqueError::Shared { ref_count })),
-            None => Err((self, NotUniqueError::NotRefCounted)),
+            Some(ref_count) => Err((self, ref_count)),
+            None => unreachable!(),
         }
     }
 }
@@ -774,5 +775,5 @@ impl<T: GodotClass> std::hash::Hash for Gd<T> {
 impl<T: GodotClass> std::panic::UnwindSafe for Gd<T> {}
 impl<T: GodotClass> std::panic::RefUnwindSafe for Gd<T> {}
 
-#[deprecated = "Moved to `godot::meta::error`"]
-pub use crate::meta::error::NotUniqueError;
+#[deprecated = "Removed; see `Gd::try_to_unique()`"]
+pub type NotUniqueError = ();

godot-core/src/obj/gd.rs

@@ -6,19 +6,20 @@
  */
 
 use std::error::Error;
+use std::fmt;
 
 use crate::gen::classes::FileAccess;
 use crate::global::Error as GodotError;
-use crate::obj::{Gd, NotUniqueError};
+use crate::obj::Gd;
 
 /// Error that can occur while using `gdext` IO utilities.
 #[derive(Debug)]
 pub struct IoError {
     data: ErrorData,
 }
 
-impl std::fmt::Display for IoError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl fmt::Display for IoError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match &self.data {
             ErrorData::Load(err) => err.fmt(f),
             ErrorData::Save(err) => err.fmt(f),
@@ -29,14 +30,12 @@ impl std::fmt::Display for IoError {
 
 impl Error for IoError {
     fn source(&self) -> Option<&(dyn Error + 'static)> {
-        if let ErrorData::GFile(GFileError {
-            kind: GFileErrorKind::NotUniqueRef(err),
-            ..
-        }) = &self.data
-        {
-            return Some(err);
+        // Note: inner types are not public, but the dyn trait can be used.
+        match &self.data {
+            ErrorData::Load(err) => Some(err),
+            ErrorData::Save(err) => Some(err),
+            ErrorData::GFile(err) => Some(err),
         }
-        None
     }
 }
 
@@ -87,23 +86,27 @@ impl IoError {
 
         match file_access.try_to_unique() {
             Ok(gd) => Ok(gd),
-            Err((_, err)) => Err(Self {
+            Err((_drop, ref_count)) => Err(Self {
                 data: ErrorData::GFile(GFileError {
-                    kind: GFileErrorKind::NotUniqueRef(err),
+                    kind: GFileErrorKind::NotUniqueRef { ref_count },
                     path: path.to_string(),
                 }),
             }),
         }
     }
 }
 
+// ----------------------------------------------------------------------------------------------------------------------------------------------
+
 #[derive(Debug)]
 enum ErrorData {
     Load(LoaderError),
     Save(SaverError),
     GFile(GFileError),
 }
 
+// ----------------------------------------------------------------------------------------------------------------------------------------------
+
 #[derive(Debug)]
 struct LoaderError {
     kind: LoaderErrorKind,
@@ -117,8 +120,10 @@ enum LoaderErrorKind {
     Cast,
 }
 
-impl std::fmt::Display for LoaderError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl Error for LoaderError {}
+
+impl fmt::Display for LoaderError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let class = &self.class;
         let path = &self.path;
 
@@ -135,15 +140,19 @@ impl std::fmt::Display for LoaderError {
     }
 }
 
+// ----------------------------------------------------------------------------------------------------------------------------------------------
+
 #[derive(Debug)]
 struct SaverError {
     class: String,
     path: String,
     godot_error: GodotError,
 }
 
-impl std::fmt::Display for SaverError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl Error for SaverError {}
+
+impl fmt::Display for SaverError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let class = &self.class;
         let path = &self.path;
         let godot_error = &self.godot_error;
@@ -152,6 +161,8 @@ impl std::fmt::Display for SaverError {
     }
 }
 
+// ----------------------------------------------------------------------------------------------------------------------------------------------
+
 #[derive(Debug)]
 struct GFileError {
     kind: GFileErrorKind,
@@ -160,17 +171,22 @@ struct GFileError {
 
 #[derive(Debug)]
 enum GFileErrorKind {
-    NotUniqueRef(NotUniqueError),
+    NotUniqueRef { ref_count: usize },
     NotOpen,
 }
 
-impl std::fmt::Display for GFileError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl Error for GFileError {}
+
+impl fmt::Display for GFileError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let path = &self.path;
 
         match &self.kind {
-            GFileErrorKind::NotUniqueRef(err) => {
-                write!(f, "access to file '{path}' is not unique: '{err}'")
+            GFileErrorKind::NotUniqueRef { ref_count } => {
+                write!(
+                    f,
+                    "Gd<FileAccess> for '{path}' is not unique (ref-count {ref_count})"
+                )
             }
             GFileErrorKind::NotOpen => write!(f, "access to file '{path}' is not open"),
         }

godot-core/src/tools/io_error.rs

@@ -14,7 +14,6 @@ use godot::classes::{
     RefCounted,
 };
 use godot::global::instance_from_id;
-use godot::meta::error::NotUniqueError;
 use godot::meta::{FromGodot, GodotType, ToGodot};
 use godot::obj::{Base, Gd, Inherits, InstanceId, NewAlloc, NewGd, RawGd};
 use godot::register::{godot_api, GodotClass};
@@ -849,19 +848,9 @@ fn object_try_to_unique() {
     assert_eq!(a.instance_id(), id);
 
     let b = a.clone();
-    let (b, err) = b.try_to_unique().expect_err("b.try_to_unique()");
+    let (b, ref_count) = b.try_to_unique().expect_err("b.try_to_unique()");
     assert_eq!(b.instance_id(), id);
-    assert!(matches!(err, NotUniqueError::Shared { ref_count: 2 }));
-
-    /* Re-enable if DynMemory is fixed.
-
-    let c = Object::new_alloc(); // manually managed
-    let id = c.instance_id();
-    let (c, err) = c.try_to_unique().expect_err("c.try_to_unique()");
-    assert_eq!(c.instance_id(), id);
-    assert!(matches!(err, NotUniqueError::NotRefCounted));
-    c.free();
-    */
+    assert_eq!(ref_count, 2);
 }
 
 // ----------------------------------------------------------------------------------------------------------------------------------------------