feat(Export): add #[export(...)] attribute

Author: Bogay

gdnative-derive/src/export.rs

@@ -1,25 +1,134 @@
 use crate::crate_gdnative_core;
-use proc_macro2::{Span, TokenStream as TokenStream2};
+use proc_macro2::{Ident, Span, TokenStream as TokenStream2};
+use quote::ToTokens;
 use syn::spanned::Spanned;
-use syn::{DeriveInput, Fields};
+use syn::{DeriveInput, Fields, Meta};
+
+#[derive(Copy, Clone, Debug)]
+enum Kind {
+    Enum,
+}
+
+#[derive(Debug)]
+struct DeriveData {
+    kind: Kind,
+    ident: Ident,
+    data: syn::Data,
+}
+
+fn parse_derive_input(input: DeriveInput) -> syn::Result<DeriveData> {
+    let DeriveInput {
+        ident, data, attrs, ..
+    } = input.clone();
+
+    let (kind, errors) = attrs
+        .iter()
+        .filter(|attr| attr.path.is_ident("export"))
+        .fold((None, vec![]), |(mut kind, mut errors), attr| {
+            let list = match attr.parse_meta() {
+                Ok(meta) => match meta {
+                    Meta::List(list) => list,
+                    Meta::Path(path) => {
+                        errors.push(syn::Error::new(
+                            path.span(),
+                            "missing macro arguments. expected #[export(...)]",
+                        ));
+                        return (kind, errors);
+                    }
+                    Meta::NameValue(pair) => {
+                        errors.push(syn::Error::new(
+                            pair.span(),
+                            "missing macro arguments. expected #[export(...)]",
+                        ));
+                        return (kind, errors);
+                    }
+                },
+                Err(e) => {
+                    errors.push(syn::Error::new(
+                        e.span(),
+                        format!("unknown attribute format. expected #[export(...)]: {e}"),
+                    ));
+                    return (kind, errors);
+                }
+            };
+
+            for meta in list.nested.into_iter() {
+                let syn::NestedMeta::Meta(Meta::NameValue(pair)) = meta else {
+                    errors.push(syn::Error::new(
+                        meta.span(),
+                        "invalid syntax. expected #[export(key = \"value\")]",
+                    ));
+                    continue;
+                };
+
+                if !pair.path.is_ident("kind") {
+                    errors.push(syn::Error::new(
+                        pair.span(),
+                        format!("found {}, expected kind", pair.path.into_token_stream()),
+                    ));
+                    continue;
+                }
+
+                let syn::Lit::Str(str) = pair.lit else {
+                    errors.push(syn::Error::new(
+                        pair.lit.span(),
+                        "string literal expected, wrap with double quotes",
+                    ));
+                    continue;
+                };
+
+                match str.value().as_str() {
+                    "enum" => {
+                        if kind.is_some() {
+                            errors.push(syn::Error::new(str.span(), "kind already set"));
+                        } else {
+                            kind = Some(Kind::Enum);
+                        }
+                    }
+                    _ => {
+                        errors.push(syn::Error::new(str.span(), "unknown kind, expected enum"));
+                    }
+                }
+            }
+
+            (kind, errors)
+        });
+
+    if let Some(err) = errors.into_iter().reduce(|mut acc, err| {
+        acc.combine(err);
+        acc
+    }) {
+        return Err(err);
+    }
+
+    match kind {
+        Some(kind) => Ok(DeriveData { ident, kind, data }),
+        None => Err(syn::Error::new(Span::call_site(), "kind not found")),
+    }
+}
 
 fn err_only_supports_fieldless_enums(span: Span) -> syn::Error {
     syn::Error::new(span, "#[derive(Export)] only supports fieldless enums")
 }
 
-pub(crate) fn derive_export(input: &DeriveInput) -> syn::Result<TokenStream2> {
-    let derived_enum = match &input.data {
-        syn::Data::Enum(data) => data,
-        syn::Data::Struct(data) => {
-            return Err(err_only_supports_fieldless_enums(data.struct_token.span()));
-        }
-        syn::Data::Union(data) => {
-            return Err(err_only_supports_fieldless_enums(data.union_token.span()));
-        }
-    };
+pub(crate) fn derive_export(input: DeriveInput) -> syn::Result<TokenStream2> {
+    let derive_data = parse_derive_input(input)?;
 
-    let export_impl = impl_export(&input.ident, derived_enum)?;
-    Ok(export_impl)
+    match derive_data.kind {
+        Kind::Enum => {
+            let derived_enum = match derive_data.data {
+                syn::Data::Enum(data) => data,
+                syn::Data::Struct(data) => {
+                    return Err(err_only_supports_fieldless_enums(data.struct_token.span()));
+                }
+                syn::Data::Union(data) => {
+                    return Err(err_only_supports_fieldless_enums(data.union_token.span()));
+                }
+            };
+            let export_impl = impl_export(&derive_data.ident, &derived_enum)?;
+            Ok(export_impl)
+        }
+    }
 }
 
 fn impl_export(enum_ty: &syn::Ident, data: &syn::DataEnum) -> syn::Result<TokenStream2> {

gdnative-derive/src/lib.rs

@@ -676,6 +676,7 @@ pub fn godot_wrap_method(input: TokenStream) -> TokenStream {
 ///
 /// #[derive(Debug, PartialEq, Clone, Copy, Export, ToVariant, FromVariant)]
 /// #[variant(enum = "repr")]
+/// #[export(kind = "enum")]
 /// #[repr(i32)]
 /// enum Dir {
 ///     Up = 1,
@@ -712,10 +713,10 @@ pub fn godot_wrap_method(input: TokenStream) -> TokenStream {
 ///   f1: i32
 /// }
 /// ```
-#[proc_macro_derive(Export)]
+#[proc_macro_derive(Export, attributes(export))]
 pub fn derive_export(input: TokenStream) -> TokenStream {
     let derive_input = syn::parse_macro_input!(input as syn::DeriveInput);
-    match export::derive_export(&derive_input) {
+    match export::derive_export(derive_input) {
         Ok(stream) => stream.into(),
         Err(err) => err.to_compile_error().into(),
     }

gdnative/tests/ui.rs

@@ -46,6 +46,12 @@ fn ui_tests() {
     t.compile_fail("tests/ui/export_fail_01.rs");
     t.compile_fail("tests/ui/export_fail_02.rs");
     t.compile_fail("tests/ui/export_fail_03.rs");
+    t.compile_fail("tests/ui/export_fail_04.rs");
+    t.compile_fail("tests/ui/export_fail_05.rs");
+    t.compile_fail("tests/ui/export_fail_06.rs");
+    t.compile_fail("tests/ui/export_fail_07.rs");
+    t.compile_fail("tests/ui/export_fail_08.rs");
+    t.compile_fail("tests/ui/export_fail_09.rs");
 }
 
 // FIXME(rust/issues/54725): Full path spans are only available on nightly as of now

gdnative/tests/ui/export_fail_01.rs

@@ -1,6 +1,7 @@
 use gdnative::prelude::*;
 
 #[derive(Export, ToVariant)]
+#[export(kind = "enum")]
 pub enum Foo {
     Bar(String),
     Baz { a: i32, b: u32 },

gdnative/tests/ui/export_fail_01.stderr

@@ -1,11 +1,11 @@
 error: #[derive(Export)] only supports fieldless enums
- --> tests/ui/export_fail_01.rs:5:5
+ --> tests/ui/export_fail_01.rs:6:5
   |
-5 |     Bar(String),
+6 |     Bar(String),
   |     ^^^
 
 error: #[derive(Export)] only supports fieldless enums
- --> tests/ui/export_fail_01.rs:6:5
+ --> tests/ui/export_fail_01.rs:7:5
   |
-6 |     Baz { a: i32, b: u32 },
+7 |     Baz { a: i32, b: u32 },
   |     ^^^

gdnative/tests/ui/export_fail_02.rs

@@ -1,6 +1,7 @@
 use gdnative::prelude::*;
 
 #[derive(Export, ToVariant)]
+#[export(kind = "enum")]
 pub struct Foo {
     bar: i32,
 }

gdnative/tests/ui/export_fail_02.stderr

@@ -1,5 +1,5 @@
 error: #[derive(Export)] only supports fieldless enums
- --> tests/ui/export_fail_02.rs:4:5
+ --> tests/ui/export_fail_02.rs:5:5
   |
-4 | pub struct Foo {
+5 | pub struct Foo {
   |     ^^^^^^

gdnative/tests/ui/export_fail_03.rs

@@ -1,6 +1,7 @@
 use gdnative::prelude::*;
 
 #[derive(Export, ToVariant)]
+#[export(kind = "enum")]
 pub union Foo {
     bar: i32,
 }

gdnative/tests/ui/export_fail_03.stderr

@@ -1,11 +1,11 @@
 error: #[derive(Export)] only supports fieldless enums
- --> tests/ui/export_fail_03.rs:4:5
+ --> tests/ui/export_fail_03.rs:5:5
   |
-4 | pub union Foo {
+5 | pub union Foo {
   |     ^^^^^
 
 error: Variant conversion derive macro does not work on unions.
  --> tests/ui/export_fail_03.rs:4:1
   |
-4 | pub union Foo {
-  | ^^^
+4 | #[export(kind = "enum")]
+  | ^

gdnative/tests/ui/export_fail_04.rs

@@ -0,0 +1,21 @@
+use gdnative::prelude::*;
+
+#[derive(Export, ToVariant)]
+#[export]
+pub enum Foo {
+    Bar,
+}
+
+#[derive(Export, ToVariant)]
+#[export = "foo"]
+pub enum Bar {
+    Foo,
+}
+
+#[derive(Export, ToVariant)]
+#[export(weird format a => b)]
+pub enum Baz {
+    Quux,
+}
+
+fn main() {}