A quick and dirty hack to enable 'outer' and 'inner' attrs to be consumed in unit variants of enum (#35)

Author: TonyWu20

derive/src/attributes.rs

@@ -32,6 +32,7 @@ pub(crate) enum DeriveAttribute {
     Rule(RuleAttribute),
 }
 
+#[derive(Debug)]
 /// `#[pest_ast(..)]` for fields in `#[derive(FromPest)]`
 pub(crate) enum FieldAttribute {
     /// `outer(with(path::to),*)`
@@ -47,12 +48,14 @@ pub(crate) struct GrammarAttribute {
     pub(crate) lit: LitStr,
 }
 
+#[derive(Debug)]
 pub(crate) struct OuterAttribute {
     pub(crate) outer: kw::outer,
     pub(crate) paren: Paren,
     pub(crate) with: Punctuated<WithAttribute, Token![,]>,
 }
 
+#[derive(Debug)]
 pub(crate) struct InnerAttribute {
     pub(crate) inner: kw::inner,
     pub(crate) paren: Paren,
@@ -61,6 +64,7 @@ pub(crate) struct InnerAttribute {
     pub(crate) with: Punctuated<WithAttribute, Token![,]>,
 }
 
+#[derive(Debug)]
 pub(crate) struct WithAttribute {
     pub(crate) with: kw::with,
     pub(crate) paren: Paren,

derive/src/from_pest/field.rs

@@ -1,3 +1,5 @@
+use syn::Variant;
+
 use {
     proc_macro2::{Span, TokenStream},
     syn::{
@@ -99,7 +101,44 @@ fn with_mods(stream: TokenStream, mods: Vec<Path>) -> TokenStream {
         .fold(stream, |stream, path| quote!(#path(#stream)))
 }
 
-pub fn convert(name: &Path, fields: Fields) -> Result<TokenStream> {
+pub fn enum_convert(name: &Path, variant: &Variant) -> Result<TokenStream> {
+    let fields = variant.fields.clone();
+    Ok(match fields {
+        Fields::Named(fields) => {
+            let fields: Vec<_> = fields
+                .named
+                .into_iter()
+                .map(|field| {
+                    let attrs = FieldAttribute::from_attributes(field.attrs)?;
+                    Ok(ConversionStrategy::from_attrs(attrs)?
+                        .apply(Member::Named(field.ident.unwrap())))
+                })
+                .collect::<Result<_>>()?;
+            quote!(#name{#(#fields,)*})
+        }
+        Fields::Unnamed(fields) => {
+            let fields: Vec<_> = fields
+                .unnamed
+                .into_iter()
+                .enumerate()
+                .map(|(i, field)| {
+                    let attrs = FieldAttribute::from_attributes(field.attrs)?;
+                    Ok(ConversionStrategy::from_attrs(attrs)?
+                        .apply(Member::Unnamed(Index::from(i))))
+                })
+                .collect::<Result<_>>()?;
+            quote!(#name(#(#fields),*))
+        }
+        Fields::Unit => {
+            let attrs = FieldAttribute::from_attributes(variant.attrs.clone())?;
+            let real_name =
+                ConversionStrategy::from_attrs(attrs)?.apply(Member::Unnamed(Index::from(0)));
+            quote!(#real_name)
+        }
+    })
+}
+
+pub fn struct_convert(name: &Path, fields: Fields) -> Result<TokenStream> {
     Ok(match fields {
         Fields::Named(fields) => {
             let fields: Vec<_> = fields
@@ -126,6 +165,8 @@ pub fn convert(name: &Path, fields: Fields) -> Result<TokenStream> {
                 .collect::<Result<_>>()?;
             quote!(#name(#(#fields),*))
         }
-        Fields::Unit => quote!(#name),
+        Fields::Unit => {
+            quote!(#name)
+        }
     })
 }

derive/src/from_pest/mod.rs

@@ -133,7 +133,7 @@ fn derive_for_struct(
         unimplemented!("Grammar introspection not implemented yet")
     }
 
-    let construct = field::convert(&parse_quote!(#name), fields)?;
+    let construct = field::struct_convert(&parse_quote!(#name), fields)?;
 
     let extraneous = crate::trace(
         quote! { "when converting {}, found extraneous {:?}", stringify!(#name), inner},
@@ -177,8 +177,8 @@ fn derive_for_enum(
     let convert_variants: Vec<TokenStream> = variants
         .into_iter()
         .map(|variant| {
-            let variant_name = variant.ident;
-            let construct_variant = field::convert(&parse_quote!(#name::#variant_name), variant.fields)?;
+            let variant_name = &variant.ident;
+            let construct_variant = field::enum_convert(&parse_quote!(#name::#variant_name), &variant)?;
             let extraneous = crate::trace(quote! {
                 "when converting {}, found extraneous {:?}", stringify!(#name), stringify!(#variant_name)
             });