feat(derive): add ExportEnum

currently the implementaion is dirty. I will refactor it after verifying it can work.

Author: Bogay

gdnative-derive/src/export_enum.rs

@@ -0,0 +1,80 @@
+use proc_macro2::TokenStream as TokenStream2;
+use syn::DeriveInput;
+
+pub(crate) fn derive_export_enum(input: &DeriveInput) -> syn::Result<TokenStream2> {
+    let derived_enum = match &input.data {
+        syn::Data::Enum(data) => data,
+        _ => todo!("return error"),
+    };
+
+    let to_variant_impl = impl_to_variant(&input.ident, derived_enum)?;
+    let from_variant_impl = impl_from_variant(&input.ident, derived_enum)?;
+    let export_impl = impl_export(&input.ident, derived_enum)?;
+    let combined_impl = quote! {
+        #to_variant_impl
+        #from_variant_impl
+        #export_impl
+    };
+
+    Ok(combined_impl)
+}
+
+fn impl_to_variant(enum_ty: &syn::Ident, _data: &syn::DataEnum) -> syn::Result<TokenStream2> {
+    let impl_block = quote! {
+        impl ::gdnative::core_types::ToVariant for #enum_ty {
+            #[inline]
+            fn to_variant(&self) -> ::gdnative::core_types::Variant {
+                (*self as i64).to_variant()
+            }
+        }
+    };
+
+    Ok(impl_block)
+}
+
+fn impl_from_variant(enum_ty: &syn::Ident, data: &syn::DataEnum) -> syn::Result<TokenStream2> {
+    // TODO: reject non-unit enum variant
+    let as_int = quote! { n };
+    let arms = data.variants.iter().map(|variant| {
+        let ident = &variant.ident;
+        quote! {
+            if #as_int == #enum_ty::#ident as i64 {
+                return Ok(#enum_ty::#ident);
+            }
+        }
+    });
+
+    let impl_block = quote! {
+        impl ::gdnative::core_types::FromVariant for #enum_ty {
+            #[inline]
+            fn from_variant(variant: &::gdnative::core_types::Variant) -> Result<Self, ::gdnative::core_types::FromVariantError> {
+                let #as_int = variant.try_to::<i64>()?;
+                #(#arms)*
+
+                panic!()
+            }
+        }
+    };
+
+    Ok(impl_block)
+}
+
+fn impl_export(enum_ty: &syn::Ident, _data: &syn::DataEnum) -> syn::Result<TokenStream2> {
+    let impl_block = quote! {
+        impl ::gdnative::export::Export for #enum_ty {
+            type Hint = ::gdnative::export::hint::IntHint<i64>;
+            #[inline]
+            fn export_info(hint: Option<Self::Hint>) -> ::gdnative::export::ExportInfo {
+                if let Some(hint) = hint {
+                    if matches!(hint, ::gdnative::export::hint::IntHint::<i64>::Enum(_)) {
+                        return hint.export_info();
+                    }
+                }
+
+                ::gdnative::export::ExportInfo::new(::gdnative::core_types::VariantType::I64)
+            }
+        }
+    };
+
+    Ok(impl_block)
+}

gdnative-derive/src/lib.rs

@@ -9,6 +9,7 @@ use proc_macro::TokenStream;
 use proc_macro2::TokenStream as TokenStream2;
 use syn::{AttributeArgs, DeriveInput, ItemFn, ItemImpl};
 
+mod export_enum;
 mod extend_bounds;
 mod methods;
 mod native_script;
@@ -482,6 +483,15 @@ pub fn derive_from_varargs(input: TokenStream) -> TokenStream {
     }
 }
 
+#[proc_macro_derive(ExportEnum)]
+pub fn derive_export_enum(input: TokenStream) -> TokenStream {
+    let derive_input = syn::parse_macro_input!(input as syn::DeriveInput);
+    match export_enum::derive_export_enum(&derive_input) {
+        Ok(stream) => stream.into(),
+        Err(err) => err.to_compile_error().into(),
+    }
+}
+
 /// Returns a standard header for derived implementations.
 ///
 /// Adds the `automatically_derived` attribute and prevents common lints from triggering