Decrease CallError size from 176 to 8 bytes

Using Box to reduce stack size, especially when used in Result<T, CallError>
return types. Should be OK since CallError is on the error path.

Notified by https://rust-lang.github.io/rust-clippy/master/index.html#result_large_err

Author: Bromeon

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

@@ -71,8 +71,14 @@ use std::fmt;
 ///     assert_eq!(inner.class_name(), Some("MyClass"));
 ///     assert_eq!(inner.method_name(), "my_method");
 /// }
-#[derive(Debug)]
 pub struct CallError {
+    // Boxed since the original struct is >= 176 bytes, making Result<..., CallError> very large.
+    b: Box<InnerCallError>,
+}
+
+/// Inner struct. All functionality on outer `impl`.
+#[derive(Debug)]
+struct InnerCallError {
     class_name: String,
     function_name: String,
     call_expr: String,
@@ -92,16 +98,16 @@ impl CallError {
     /// This is the static and not the dynamic type. For example, if you invoke `call()` on a `Gd<Node>`, you are effectively invoking
     /// `Object::call()` (through `DerefMut`), and the class name will be `Object`.
     pub fn class_name(&self) -> Option<&str> {
-        if self.class_name.is_empty() {
+        if self.b.class_name.is_empty() {
             None
         } else {
-            Some(&self.class_name)
+            Some(&self.b.class_name)
         }
     }
 
     /// Name of the function or method that failed.
     pub fn method_name(&self) -> &str {
-        &self.function_name
+        &self.b.function_name
     }
 
     // ------------------------------------------------------------------------------------------------------------------------------------------
@@ -150,8 +156,7 @@ impl CallError {
         // If the call error encodes an error generated by us, decode it.
         let mut source_error = None;
         if err.error == sys::GODOT_RUST_CUSTOM_CALL_ERROR {
-            source_error = crate::private::call_error_remove(&err) //.
-                .map(|e| SourceError::Call(Box::new(e)));
+            source_error = crate::private::call_error_remove(&err).map(SourceError::Call);
         }
 
         Err(Self::failed_varcall_inner(
@@ -295,8 +300,8 @@ impl CallError {
         //     source,
         // }
 
-        call_error.source = source;
-        call_error.call_expr = call_expr;
+        call_error.b.source = source;
+        call_error.b.call_expr = call_expr;
         call_error
     }
 
@@ -316,7 +321,7 @@ impl CallError {
         reason: impl Into<String>,
         source: Option<ConvertError>,
     ) -> Self {
-        Self {
+        let inner = InnerCallError {
             class_name: call_ctx.class_name.to_string(),
             function_name: call_ctx.function_name.to_string(),
             call_expr: format!("{call_ctx}()"),
@@ -325,17 +330,22 @@ impl CallError {
                 value: e.value().map_or_else(String::new, |v| format!("{:?}", v)),
                 erased_error: e.into(),
             }),
-        }
+        };
+
+        Self { b: Box::new(inner) }
     }
 
     /// Describes the error.
     ///
     /// This is the same as the `Display`/`ToString` repr, but without the prefix mentioning that this is a function call error,
     /// and without any source error information.
-    fn message(&self, with_source: bool) -> String {
-        let Self {
-            call_expr, reason, ..
-        } = self;
+    pub fn message(&self, with_source: bool) -> String {
+        let InnerCallError {
+            call_expr,
+            reason,
+            source,
+            ..
+        } = &*self.b;
 
         let reason_str = if reason.is_empty() {
             String::new()
@@ -351,7 +361,7 @@ impl CallError {
         //     String::new()
         // };
 
-        let source_str = match &self.source {
+        let source_str = match source {
             Some(SourceError::Convert {
                 erased_error,
                 value,
@@ -361,7 +371,10 @@ impl CallError {
                     if value.is_empty() { "" } else { ": " },
                 )
             }
-            Some(SourceError::Call(e)) if with_source => format!("\n  Source: {}", e.message(true)),
+            Some(SourceError::Call(e)) if with_source => {
+                let message = e.message(true);
+                format!("\n  Source: {message}")
+            }
             _ => String::new(),
         };
 
@@ -371,13 +384,21 @@ impl CallError {
 
 impl fmt::Display for CallError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "godot-rust function call failed: {}", self.message(true))
+        let message = self.message(true);
+        write!(f, "godot-rust function call failed: {message}")
+    }
+}
+
+impl fmt::Debug for CallError {
+    // Delegate to inner box.
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{:?}", self.b)
     }
 }
 
 impl Error for CallError {
     fn source(&self) -> Option<&(dyn Error + 'static)> {
-        match self.source.as_ref() {
+        match self.b.source.as_ref() {
             Some(SourceError::Convert {
                 erased_error: e, ..
             }) => deref_to::<ErasedConvertError>(e),
@@ -396,7 +417,9 @@ enum SourceError {
         erased_error: ErasedConvertError,
         value: String,
     },
-    Call(Box<CallError>),
+
+    // If the top-level Box on CallError is ever removed, this would need to store Box<CallError> again.
+    Call(CallError),
 }
 
 /// Explicit dereferencing to a certain type. Avoids accidentally returning `&Box<T>` or so.