All engine enums have now custom Debug implementation

Changes the Debug representation from:
  SomeEnum { ord: 43 }
to:
  CONSTANT

If there are multiple matching constants with the same value, the first one is displayed.

Author: Bromeon

godot-codegen/src/generator/enums.rs

@@ -50,6 +50,8 @@ pub fn make_enum_definition_with(
     let engine_trait = enum_.engine_trait();
 
     let definition = define_enum.then(|| {
+        let debug_impl = make_enum_debug_impl(enum_);
+
         // Workaround because traits are defined in separate crate, but need access to field `ord`.
         let vis = (!define_traits).then(|| {
             quote! {
@@ -68,6 +70,8 @@ pub fn make_enum_definition_with(
             impl #name {
                 #( #enumerators )*
             }
+
+            #debug_impl
         }
     });
 
@@ -121,6 +125,41 @@ fn make_enum_index_impl(enum_: &Enum) -> Option<TokenStream> {
     })
 }
 
+/// Implement `Debug` trait for the enum.
+fn make_enum_debug_impl(enum_: &Enum) -> TokenStream {
+    let enum_name = &enum_.name;
+    let enum_name_str = enum_name.to_string();
+
+    let enumerators = enum_.enumerators.iter().map(|enumerator| {
+        let Enumerator { name, .. } = enumerator;
+        let name_str = name.to_string();
+        quote! {
+            Self::#name => #name_str,
+        }
+    });
+
+    quote! {
+        impl std::fmt::Debug for #enum_name {
+            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                // Many enums have duplicates, thus allow unreachable.
+                // In the future, we could print sth like "ONE|TWO" instead (at least for unstable Debug).
+                #[allow(unreachable_patterns)]
+                let enumerator = match *self {
+                    #( #enumerators )*
+                    _ => {
+                        f.debug_struct(#enum_name_str)
+                        .field("ord", &self.ord)
+                        .finish()?;
+                        return Ok(());
+                    }
+                };
+
+                f.write_str(enumerator)
+            }
+        }
+    }
+}
+
 /// Creates an implementation of the engine trait for the given enum.
 ///
 /// This will implement the trait returned by [`Enum::engine_trait`].

godot-codegen/src/models/domain/enums.rs

@@ -24,7 +24,8 @@ pub struct Enum {
 impl Enum {
     /// Which traits should be derived for this enum.
     pub fn derives(&self) -> Vec<Ident> {
-        let mut derives = vec!["Copy", "Clone", "Eq", "PartialEq", "Hash", "Debug"];
+        // Debug is implemented manually, using enumerator name. This can be derived once we use proper enums.
+        let mut derives = vec!["Copy", "Clone", "Eq", "PartialEq", "Hash"];
 
         if self.is_bitfield {
             derives.push("Default");

itest/rust/src/object_tests/dynamic_call_test.rs

@@ -135,7 +135,7 @@ fn dynamic_call_parameter_mismatch() {
         "godot-rust function call failed: Object::call(&\"take_1_int\", [va] \"string\")\
         \n  Source: ObjPayload::take_1_int()\
         \n    Reason: parameter #0 (i64) conversion\
-        \n  Source: expected type Int, got String: \"string\""
+        \n  Source: expected type INT, got STRING: \"string\""
     );
 
     obj.free();
@@ -256,7 +256,7 @@ fn dynamic_call_parameter_mismatch_engine() {
     assert_eq!(
         call_error.to_string(),
         "godot-rust function call failed: Object::call(&\"set_name\", [va] 123)\
-        \n    Reason: parameter #1 conversion -- expected type String, got Int"
+        \n    Reason: parameter #1 conversion -- expected type STRING, got INT"
     );
 
     node.free();