Merge pull request #1011 from godot-rust/bugfix/enum-hint-ord

Fix `#[derive(Var)]` generating incorrect `hint_string` for enums

Author: Bromeon

godot-macros/src/derive/data_models/c_style_enum.rs

@@ -9,6 +9,7 @@ use crate::util::bail;
 use crate::ParseResult;
 use proc_macro2::{Ident, Span, TokenStream, TokenTree};
 use quote::{quote, ToTokens};
+use std::fmt::Write;
 
 /// Stores info from C-style enums for use in deriving `GodotConvert` and other related traits.
 #[derive(Clone, Debug)]
@@ -87,22 +88,45 @@ impl CStyleEnum {
     }
 
     /// Return a hint string for use with `PropertyHint::ENUM` where each variant has an explicit integer hint.
-    pub fn to_int_hint(&self) -> String {
-        self.enumerator_names
+    pub fn to_int_hint(&self) -> TokenStream {
+        // We can't build the format string directly, since the ords may be expressions and not literals.
+        // Thus generate code containing a format!() statement.
+
+        let iter = self
+            .enumerator_names
             .iter()
-            .zip(self.enumerator_ords.iter())
-            .map(|(name, discrim)| format!("{name}:{discrim}"))
-            .collect::<Vec<_>>()
-            .join(",")
+            .zip(self.enumerator_ords.iter());
+
+        let mut fmt = String::new();
+        let mut fmt_args = Vec::new();
+        let mut first = true;
+
+        for (name, discrim) in iter {
+            if first {
+                first = false;
+            } else {
+                fmt.push(',');
+            }
+
+            write!(fmt, "{name}:{{}}").expect("write to string");
+            fmt_args.push(discrim.clone());
+        }
+
+        quote! {
+            format!(#fmt, #(#fmt_args),*)
+        }
     }
 
     /// Return a hint string for use with `PropertyHint::ENUM` where the variants are just kept as strings.
-    pub fn to_string_hint(&self) -> String {
-        self.enumerator_names
+    pub fn to_string_hint(&self) -> TokenStream {
+        let hint_string = self
+            .enumerator_names
             .iter()
             .map(ToString::to_string)
             .collect::<Vec<_>>()
-            .join(",")
+            .join(",");
+
+        hint_string.to_token_stream()
     }
 }
 

godot-macros/src/derive/derive_var.rs

@@ -61,7 +61,7 @@ fn create_property_hint_impl(convert: &GodotConvert) -> TokenStream {
             quote! {
                 ::godot::meta::PropertyHintInfo {
                     hint: ::godot::global::PropertyHint::ENUM,
-                    hint_string: #hint_string.into(),
+                    hint_string: ::godot::builtin::GString::from(#hint_string),
                 }
             }
         }

itest/rust/src/object_tests/property_test.rs

@@ -313,6 +313,22 @@ pub enum TestEnum {
     C = 2,
 }
 
+#[derive(GodotConvert, Var)]
+#[godot(via = i64)]
+pub enum Behavior {
+    Peaceful,
+    Defend,
+    Aggressive = (3 + 4),
+}
+
+#[derive(GodotConvert, Var)]
+#[godot(via = GString)]
+pub enum StrBehavior {
+    Peaceful,
+    Defend,
+    Aggressive = (3 + 4),
+}
+
 #[derive(GodotClass)]
 #[class(no_init)]
 pub struct DeriveProperty {
@@ -326,22 +342,38 @@ fn derive_property() {
         my_enum: TestEnum::B,
     };
     assert_eq!(class.get_my_enum(), TestEnum::B as i64);
+
     class.set_my_enum(TestEnum::C as i64);
     assert_eq!(class.my_enum, TestEnum::C);
 }
 
+// Regression test for https://github.com/godot-rust/gdext/issues/1009.
+#[itest]
+fn enum_var_hint() {
+    let int_prop = <Behavior as Var>::var_hint();
+    assert_eq!(int_prop.hint, PropertyHint::ENUM);
+    assert_eq!(
+        int_prop.hint_string,
+        "Peaceful:0,Defend:1,Aggressive:7".into()
+    );
+
+    let str_prop = <StrBehavior as Var>::var_hint();
+    assert_eq!(str_prop.hint, PropertyHint::ENUM);
+    assert_eq!(str_prop.hint_string, "Peaceful,Defend,Aggressive".into());
+}
+
 #[derive(GodotClass)]
 pub struct DeriveExport {
     #[export]
     pub my_enum: TestEnum,
 
     // Tests also qualified base path (type inference of Base<T> without #[hint]).
-    pub base: godot::obj::Base<RefCounted>,
+    pub base: Base<RefCounted>,
 }
 
 #[godot_api]
 impl IRefCounted for DeriveExport {
-    fn init(base: godot::obj::Base<Self::Base>) -> Self {
+    fn init(base: Base<Self::Base>) -> Self {
         Self {
             my_enum: TestEnum::B,
             base,