Add ConvertError

Make `FromGodot` use `Result<Via, ConvertError>`
Fix up everything to use the new fallible methods
Make itests use `expect` and `expect_err` for fallible conversion testing
Add some tests to ensure conversion works as expected

Author: lilizoey

godot-codegen/src/class_generator.rs

@@ -925,8 +925,8 @@ fn make_native_structure(
         }
 
         impl FromGodot for *mut #class_name {
-            fn try_from_godot(via: Self::Via) -> Option<Self> {
-                Some(via as Self)
+            fn try_from_godot(via: Self::Via) -> Result<Self, crate::builtin::meta::ConvertError> {
+                Ok(via as Self)
             }
         }
 
@@ -941,8 +941,8 @@ fn make_native_structure(
         }
 
         impl FromGodot for *const #class_name {
-            fn try_from_godot(via: Self::Via) -> Option<Self> {
-                Some(via as Self)
+            fn try_from_godot(via: Self::Via) -> Result<Self, crate::builtin::meta::ConvertError> {
+                Ok(via as Self)
             }
         }
     };
@@ -1286,6 +1286,7 @@ fn make_builtin_method_definition(
 
         <CallSig as PtrcallSignatureTuple>::out_builtin_ptrcall::<RetMarshal>(
             method_bind,
+            #method_name_str,
             #object_ptr,
             args
         )
@@ -1345,6 +1346,7 @@ pub(crate) fn make_utility_function_definition(
 
         <CallSig as PtrcallSignatureTuple>::out_utility_ptrcall(
             utility_fn,
+            #function_name_str,
             args
         )
     };
@@ -1354,6 +1356,7 @@ pub(crate) fn make_utility_function_definition(
 
         <CallSig as VarcallSignatureTuple>::out_utility_ptrcall_varargs(
             utility_fn,
+            #function_name_str,
             args,
             varargs
         )

godot-codegen/src/util.rs

@@ -337,8 +337,9 @@ pub fn make_enum_definition(enum_: &Enum) -> TokenStream {
         }
 
         impl crate::builtin::meta::FromGodot for #enum_name {
-            fn try_from_godot(via: Self::Via) -> Option<Self> {
+            fn try_from_godot(via: Self::Via) -> std::result::Result<Self, crate::builtin::meta::ConvertError> {
                 <Self as crate::obj::EngineEnum>::try_from_ord(via)
+                    .ok_or_else(|| crate::builtin::meta::FromGodotError::InvalidEnum.into_error(via))
             }
         }
 

godot-core/src/builtin/array.rs

@@ -13,7 +13,10 @@ use std::fmt;
 use std::marker::PhantomData;
 use sys::{ffi_methods, interface_fn, GodotFfi};
 
-use super::meta::{FromGodot, GodotConvert, GodotFfiVariant, GodotType, ToGodot};
+use super::meta::{
+    ConvertError, FromGodot, FromGodotError, FromVariantError, GodotConvert, GodotFfiVariant,
+    GodotType, ToGodot,
+};
 
 /// Godot's `Array` type.
 ///
@@ -337,11 +340,18 @@ impl<T: GodotType> Array<T> {
     }
 
     /// Checks that the inner array has the correct type set on it for storing elements of type `T`.
-    fn with_checked_type(self) -> Result<Self, VariantConversionError> {
-        if self.type_info() == TypeInfo::of::<T>() {
+    fn with_checked_type(self) -> Result<Self, ConvertError> {
+        let self_ty = self.type_info();
+        let target_ty = TypeInfo::of::<T>();
+
+        if self_ty == target_ty {
             Ok(self)
         } else {
-            Err(VariantConversionError::BadType)
+            Err(FromGodotError::BadArrayType {
+                expected: target_ty,
+                got: self_ty,
+            }
+            .into_error(self))
         }
     }
 
@@ -633,11 +643,15 @@ impl<T: GodotType> ToGodot for Array<T> {
     fn into_godot(self) -> Self::Via {
         self
     }
+
+    fn to_variant(&self) -> Variant {
+        self.ffi_to_variant()
+    }
 }
 
 impl<T: GodotType> FromGodot for Array<T> {
-    fn try_from_godot(via: Self::Via) -> Option<Self> {
-        Some(via)
+    fn try_from_godot(via: Self::Via) -> Result<Self, ConvertError> {
+        Ok(via)
     }
 }
 
@@ -755,15 +769,16 @@ impl<T: GodotType> GodotType for Array<T> {
     type Ffi = Self;
 
     fn to_ffi(&self) -> Self::Ffi {
+        // `to_ffi` is sometimes intentionally called with an array in an invalid state.
         self.clone()
     }
 
     fn into_ffi(self) -> Self::Ffi {
         self
     }
 
-    fn try_from_ffi(ffi: Self::Ffi) -> Option<Self> {
-        Some(ffi)
+    fn try_from_ffi(ffi: Self::Ffi) -> Result<Self, ConvertError> {
+        Ok(ffi)
     }
 
     fn godot_type_name() -> String {
@@ -781,9 +796,13 @@ impl<T: GodotType> GodotFfiVariant for Array<T> {
         }
     }
 
-    fn ffi_from_variant(variant: &Variant) -> Result<Self, VariantConversionError> {
+    fn ffi_from_variant(variant: &Variant) -> Result<Self, ConvertError> {
         if variant.get_type() != Self::variant_type() {
-            return Err(VariantConversionError::BadType);
+            return Err(FromVariantError::BadType {
+                expected: Self::variant_type(),
+                got: variant.get_type(),
+            }
+            .into_error(variant.clone()));
         }
 
         let array = unsafe {
@@ -992,7 +1011,7 @@ macro_rules! varray {
 ///
 /// We ignore the `script` parameter because it has no impact on typing in Godot.
 #[derive(PartialEq, Eq)]
-struct TypeInfo {
+pub(crate) struct TypeInfo {
     variant_type: VariantType,
 
     /// Not a `ClassName` because some values come from Godot engine API.
@@ -1007,9 +1026,17 @@ impl TypeInfo {
         }
     }
 
-    fn is_typed(&self) -> bool {
+    pub fn is_typed(&self) -> bool {
         self.variant_type != VariantType::Nil
     }
+
+    pub fn variant_type(&self) -> VariantType {
+        self.variant_type
+    }
+
+    pub fn class_name(&self) -> &StringName {
+        &self.class_name
+    }
 }
 
 impl fmt::Debug for TypeInfo {