+fix

Author: Bromeon

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

@@ -32,21 +32,33 @@ use crate::meta::{Element, ToGodot, ref_to_arg};
 ///     #[func]
 ///     fn try_parse(&self, input: GString) -> Result<i64, ErrorAsVariant<GString>> {
 ///         input.to_string().parse::<i64>()
-///             .map_err(|e| ErrorAsVariant(GString::from(e.to_string())))
+///             .map_err(|e| ErrorAsVariant::new(&e.to_string()))
 ///     }
 /// }
 /// ```
 ///
 /// GDScript receives a `Variant`. On success, it contains the `i64` value. On error, it contains the error value.
-pub struct ErrorAsVariant<E: ToGodot>(pub E);
+pub struct ErrorAsVariant<E: ToGodot> {
+    /// The error value passed to GDScript as a `Variant`.
+    pub error: E,
+}
+
+impl ErrorAsVariant<GString> {
+    /// Creates an `ErrorAsVariant` with a string error message.
+    pub fn new(error_message: impl Into<GString>) -> Self {
+        Self {
+            error: error_message.into(),
+        }
+    }
+}
 
 impl<T: ToGodot, E: ToGodot> ErrorToGodot<T> for ErrorAsVariant<E> {
     type Mapped = Variant;
 
     fn result_to_godot(result: Result<&T, &Self>) -> Result<Variant, String> {
         match result {
             Ok(val) => Ok(val.to_variant()),
-            Err(e) => Ok(e.0.to_variant()),
+            Err(e) => Ok(e.error.to_variant()),
         }
     }
 }
@@ -115,7 +127,7 @@ impl<T: Element> ErrorToGodot<T> for ErrorAsEmptyArray {
 ///     #[func]
 ///     fn try_parse(&self, input: GString) -> Result<i64, ErrorAsDictionary<GString>> {
 ///         input.to_string().parse::<i64>()
-///             .map_err(|e| ErrorAsDictionary(GString::from(e.to_string())))
+///             .map_err(|e| ErrorAsDictionary::new(&e.to_string()))
 ///     }
 /// }
 /// ```
@@ -128,7 +140,19 @@ impl<T: Element> ErrorToGodot<T> for ErrorAsEmptyArray {
 /// else:
 ///     print("Parse failed: ", result["err"])
 /// ```
-pub struct ErrorAsDictionary<E: ToGodot>(pub E);
+pub struct ErrorAsDictionary<E: ToGodot> {
+    /// The error value stored under `"err"` in the returned dictionary.
+    pub error: E,
+}
+
+impl ErrorAsDictionary<GString> {
+    /// Creates an `ErrorAsDictionary` with a string error message.
+    pub fn new(error_message: impl Into<GString>) -> Self {
+        Self {
+            error: error_message.into(),
+        }
+    }
+}
 
 impl<T: ToGodot, E: ToGodot> ErrorToGodot<T> for ErrorAsDictionary<E> {
     type Mapped = Dictionary<GString, Variant>;
@@ -137,7 +161,7 @@ impl<T: ToGodot, E: ToGodot> ErrorToGodot<T> for ErrorAsDictionary<E> {
         let mut d = Dictionary::new();
         match result {
             Ok(val) => d.set("ok", &val.to_variant()),
-            Err(e) => d.set("err", &e.0.to_variant()),
+            Err(e) => d.set("err", &e.error.to_variant()),
         }
         Ok(d)
     }

itest/rust/src/register_tests/func_result_test.rs

@@ -105,7 +105,7 @@ impl FuncResulter {
 
     #[func]
     fn variant_err(&self) -> Result<i64, ErrorAsVariant<GString>> {
-        Err(ErrorAsVariant(GString::from("variant error")))
+        Err(ErrorAsVariant::new("variant error"))
     }
 
     // ------------------------------------------------------------------------------------------------------------------------------------------
@@ -131,7 +131,7 @@ impl FuncResulter {
 
     #[func]
     fn dict_err(&self) -> Result<i64, ErrorAsDictionary<GString>> {
-        Err(ErrorAsDictionary(GString::from("dict error")))
+        Err(ErrorAsDictionary::new("dict error"))
     }
 }