Improve error messages + test (also in other GodotConvert cases)

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

@@ -188,9 +188,8 @@ impl CallError {
         expected: VariantType,
     ) -> Self {
         // Note: reason is same wording as in FromVariantError::description().
-        let reason = format!(
-            "parameter #{param_index} conversion -- expected type {expected:?}, got {actual:?}"
-        );
+        let reason =
+            format!("parameter #{param_index} -- cannot convert from {actual:?} to {expected:?}");
 
         Self::new(call_ctx, reason, None)
     }

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

@@ -183,10 +183,13 @@ pub(crate) enum FromGodotError {
 
     /// Cannot map object to `dyn Trait` because none of the known concrete classes implements it.
     UnimplementedDynTrait {
-        trait_id: std::any::TypeId,
+        trait_name: String,
         class_name: String,
     },
 
+    /// Cannot map object to `dyn Trait` because none of the known concrete classes implements it.
+    UnregisteredDynTrait { trait_name: String },
+
     /// `InstanceId` cannot be 0.
     ZeroInstanceId,
 }
@@ -242,12 +245,18 @@ impl fmt::Display for FromGodotError {
             Self::InvalidEnum => write!(f, "invalid engine enum value"),
             Self::ZeroInstanceId => write!(f, "`InstanceId` cannot be 0"),
             Self::UnimplementedDynTrait {
-                trait_id,
+                trait_name,
                 class_name,
             } => {
                 write!(
                     f,
-                    "none of the derived classes from {class_name} have been registered with trait {trait_id:?}"
+                    "none of the classes derived from `{class_name}` have been linked to trait `{trait_name}` with #[godot_dyn]"
+                )
+            }
+            FromGodotError::UnregisteredDynTrait { trait_name } => {
+                write!(
+                    f,
+                    "trait `{trait_name}` has not been registered with #[godot_dyn]"
                 )
             }
         }
@@ -328,11 +337,11 @@ impl fmt::Display for FromVariantError {
         match self {
             Self::BadType { expected, actual } => {
                 // Note: wording is the same as in CallError::failed_param_conversion_engine()
-                write!(f, "expected type {expected:?}, got {actual:?}")
+                write!(f, "cannot convert from type {actual:?} to {expected:?}")
             }
             Self::BadValue => write!(f, "value cannot be represented in target type's domain"),
             Self::WrongClass { expected } => {
-                write!(f, "expected class {expected}")
+                write!(f, "cannot convert to class {expected}")
             }
         }
     }

godot-core/src/registry/class.rs

@@ -292,13 +292,14 @@ pub fn auto_register_rpcs<T: GodotClass>(object: &mut T) {
 pub(crate) fn try_dynify_object<T: GodotClass, D: ?Sized + 'static>(
     object: Gd<T>,
 ) -> Result<DynGd<T, D>, ConvertError> {
-    let typeid = std::any::TypeId::of::<D>();
+    let typeid = any::TypeId::of::<D>();
+    let trait_name = sys::short_type_name::<D>();
 
     // Iterate all classes that implement the trait.
     let dyn_traits_by_typeid = global_dyn_traits_by_typeid();
-    let relations = dyn_traits_by_typeid.get(&typeid).unwrap_or_else(|| {
-        panic!("Trait '{typeid:?}' has not been registered with #[godot_dyn].");
-    });
+    let Some(relations) = dyn_traits_by_typeid.get(&typeid) else {
+        return Err(FromGodotError::UnregisteredDynTrait { trait_name }.into_error(object));
+    };
 
     // TODO maybe use 2nd hashmap instead of linear search.
     // (probably not pair of typeid/classname, as that wouldn't allow the above check).
@@ -322,7 +323,7 @@ pub(crate) fn try_dynify_object<T: GodotClass, D: ?Sized + 'static>(
     }
 
     let error = FromGodotError::UnimplementedDynTrait {
-        trait_id: typeid,
+        trait_name,
         class_name: dynamic_class.to_string(),
     };
 

itest/rust/src/builtin_tests/containers/variant_test.rs

@@ -130,6 +130,25 @@ fn variant_bad_conversions() {
         .expect_err("`nil` should not convert to `Dictionary`");
 }
 
+#[itest]
+fn variant_bad_conversion_error_message() {
+    let variant = 123.to_variant();
+
+    let err = variant
+        .try_to::<GString>()
+        .expect_err("i32 -> GString conversion should fail");
+    assert_eq!(
+        err.to_string(),
+        "cannot convert from type INT to STRING: 123"
+    );
+
+    // TODO this error isn't great, but unclear whether it can be improved. If not, document.
+    let err = variant
+        .try_to::<Gd<Node>>()
+        .expect_err("i32 -> Gd<Node> conversion should fail");
+    assert_eq!(err.to_string(), "`Gd` cannot be null: null");
+}
+
 #[itest]
 fn variant_array_bad_conversions() {
     let i32_array: Array<i32> = array![1, 2, 160, -40];

itest/rust/src/object_tests/dyn_gd_test.rs

@@ -295,6 +295,40 @@ fn dyn_gd_store_in_godot_array() {
     array.at(1).free();
 }
 
+#[itest]
+fn dyn_gd_error_unregistered_trait() {
+    trait UnrelatedTrait {}
+
+    let obj = Gd::from_object(RefcHealth { hp: 33 }).into_dyn::<dyn Health>();
+
+    let variant = obj.to_variant();
+    let back = variant.try_to::<DynGd<RefcHealth, dyn UnrelatedTrait>>();
+
+    let err = back.expect_err("DynGd::try_to() should have failed");
+    let expected_err = {
+        // The conversion fails before a DynGd is created, so Display still operates on the Gd.
+        let obj = obj.into_gd();
+
+        format!("trait `dyn UnrelatedTrait` has not been registered with #[godot_dyn]: {obj:?}")
+    };
+
+    assert_eq!(err.to_string(), expected_err);
+}
+
+#[itest]
+fn dyn_gd_error_unimplemented_trait() {
+    let obj = RefCounted::new_gd(); //Gd::from_object(RefcHealth { hp: 33 }).into_dyn::<dyn Health>();
+
+    let variant = obj.to_variant();
+    let back = variant.try_to::<DynGd<RefCounted, dyn Health>>();
+
+    let err = back.expect_err("DynGd::try_to() should have failed");
+    assert_eq!(
+        err.to_string(),
+        format!("none of the classes derived from `RefCounted` have been linked to trait `dyn Health` with #[godot_dyn]: {obj:?}")
+    );
+}
+
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 // Example symbols
 

itest/rust/src/object_tests/object_test.rs

@@ -518,6 +518,20 @@ fn object_engine_convert_variant_nil() {
     });
 }
 
+#[itest]
+fn object_engine_convert_variant_error() {
+    let refc = RefCounted::new_gd();
+    let variant = refc.to_variant();
+
+    let err = Gd::<Area2D>::try_from_variant(&variant)
+        .expect_err("`Gd<RefCounted>` should not convert to `Gd<Area2D>`");
+
+    assert_eq!(
+        err.to_string(),
+        format!("cannot convert to class Area2D: {refc:?}")
+    );
+}
+
 #[itest]
 fn object_engine_returned_refcount() {
     let Some(file) = FileAccess::open("res://itest.gdextension", file_access::ModeFlags::READ)