der_derive: remove synstructure dependency (#192)

Little of `synstructure`'s actual functionality is being used, and given
all of the additional parsing work that needs to be done in the proc
macro, we already have the relevant context that `synstructure` would
abstract over.

Removing `synstructure` also means we can start using the
`proc-macro-error` crate to provide better error messages.

Author: tarcieri

Cargo.lock

@@ -18,5 +18,4 @@ proc-macro = true
 [dependencies]
 proc-macro2 = "1"
 quote = "1"
-syn = "1"
-synstructure = "0.12"
+syn = { version = "1", features = ["extra-traits"] }

der/derive/Cargo.toml

@@ -5,14 +5,19 @@
 use crate::{FieldAttrs, TypeAttrs};
 use proc_macro2::TokenStream;
 use quote::{quote, ToTokens};
-use syn::{DataEnum, Lifetime, Variant};
-use synstructure::{Structure, VariantInfo};
+use syn::{Attribute, DataEnum, Fields, Ident, Lifetime, Variant};
 
 /// Derive the `Choice` trait for an enum.
 pub(crate) struct DeriveChoice {
+    /// Name of the enum type.
+    ident: Ident,
+
     /// `asn1` attributes defined at the type level.
     type_attrs: TypeAttrs,
 
+    /// Lifetime of the type.
+    lifetime: Option<Lifetime>,
+
     /// Tags included in the impl body for `der::Choice`.
     choice_body: TokenStream,
 
@@ -31,23 +36,24 @@ pub(crate) struct DeriveChoice {
 
 impl DeriveChoice {
     /// Derive `Decodable` on an enum.
-    pub fn derive(s: Structure<'_>, data: &DataEnum, lifetime: Option<&Lifetime>) -> TokenStream {
-        assert_eq!(
-            s.variants().len(),
-            data.variants.len(),
-            "enum variant count mismatch"
-        );
-
+    pub fn derive(
+        ident: Ident,
+        data: DataEnum,
+        attrs: &[Attribute],
+        lifetime: Option<Lifetime>,
+    ) -> TokenStream {
         let mut state = Self {
-            type_attrs: TypeAttrs::parse(&s.ast().attrs),
+            ident,
+            type_attrs: TypeAttrs::parse(attrs),
+            lifetime,
             choice_body: TokenStream::new(),
             decode_body: TokenStream::new(),
             encode_body: TokenStream::new(),
             encoded_len_body: TokenStream::new(),
             tagged_body: TokenStream::new(),
         };
 
-        for (variant_info, variant) in s.variants().iter().zip(&data.variants) {
+        for variant in &data.variants {
             let field_attrs = FieldAttrs::parse(&variant.attrs);
             let tag = field_attrs.tag(&state.type_attrs).unwrap_or_else(|| {
                 panic!(
@@ -59,21 +65,21 @@ impl DeriveChoice {
             state.derive_variant_choice(&tag);
             state.derive_variant_decoder(variant, &tag, &field_attrs);
 
-            match variant_info.bindings().len() {
+            match &variant.fields {
                 // TODO(tarcieri): handle 0 bindings for ASN.1 NULL
-                1 => {
-                    state.derive_variant_encoder(variant_info, &field_attrs);
-                    state.derive_variant_encoded_len(variant_info);
+                Fields::Unnamed(fields) if fields.unnamed.len() == 1 => {
+                    state.derive_variant_encoder(variant, &field_attrs);
+                    state.derive_variant_encoded_len(variant);
                     state.derive_variant_tagged(variant, &tag);
                 }
-                other => panic!(
-                    "unsupported number of ASN.1 variant bindings for {}: {}",
-                    &variant.ident, other
+                _ => panic!(
+                    "enum variant `{}` must be a 1-element tuple struct",
+                    &variant.ident
                 ),
             }
         }
 
-        state.finish(s, lifetime)
+        state.to_tokens()
     }
 
     /// Derive the body of `Choice::can_decode
@@ -100,34 +106,17 @@ impl DeriveChoice {
     }
 
     /// Derive a match arm for the impl body for `der::Encodable::encode`.
-    fn derive_variant_encoder(&mut self, variant: &VariantInfo<'_>, field_attrs: &FieldAttrs) {
-        assert_eq!(
-            variant.bindings().len(),
-            1,
-            "unexpected number of variant bindings"
-        );
-
-        variant
-            .each(|bi| {
-                let binding = &bi.binding;
-                field_attrs.encoder(&quote!(#binding), &self.type_attrs)
-            })
-            .to_tokens(&mut self.encode_body);
+    fn derive_variant_encoder(&mut self, variant: &Variant, field_attrs: &FieldAttrs) {
+        let variant_ident = &variant.ident;
+        let binding = quote!(variant);
+        let encoder = field_attrs.encoder(&binding, &self.type_attrs);
+        { quote!(Self::#variant_ident(#binding) => #encoder,) }.to_tokens(&mut self.encode_body);
     }
 
     /// Derive a match arm for the impl body for `der::Encodable::encode`.
-    fn derive_variant_encoded_len(&mut self, variant: &VariantInfo<'_>) {
-        assert_eq!(
-            variant.bindings().len(),
-            1,
-            "unexpected number of variant bindings"
-        );
-
-        variant
-            .each(|bi| {
-                let binding = &bi.binding;
-                quote!(#binding.encoded_len())
-            })
+    fn derive_variant_encoded_len(&mut self, variant: &Variant) {
+        let variant_ident = &variant.ident;
+        { quote!(Self::#variant_ident(variant) => variant.encoded_len(),) }
             .to_tokens(&mut self.encoded_len_body);
     }
 
@@ -137,14 +126,21 @@ impl DeriveChoice {
         { quote!(Self::#variant_ident(_) => #tag,) }.to_tokens(&mut self.tagged_body);
     }
 
-    /// Finish deriving an enum
-    fn finish(self, s: Structure<'_>, lifetime: Option<&Lifetime>) -> TokenStream {
-        let lifetime = match lifetime {
-            Some(lifetime) => quote!(#lifetime),
+    /// Lower the derived output into a [`TokenStream`].
+    fn to_tokens(&self) -> TokenStream {
+        let lifetime = match self.lifetime {
+            Some(ref lifetime) => quote!(#lifetime),
             None => quote!('_),
         };
 
+        let lt_param = self
+            .lifetime
+            .as_ref()
+            .map(|_| lifetime.clone())
+            .unwrap_or_default();
+
         let Self {
+            ident,
             choice_body,
             decode_body,
             encode_body,
@@ -153,14 +149,14 @@ impl DeriveChoice {
             ..
         } = self;
 
-        s.gen_impl(quote! {
-            gen impl ::der::Choice<#lifetime> for @Self {
+        quote! {
+            impl<#lt_param> ::der::Choice<#lifetime> for #ident<#lt_param> {
                 fn can_decode(tag: ::der::Tag) -> bool {
                     matches!(tag, #choice_body)
                 }
             }
 
-            gen impl ::der::Decodable<#lifetime> for @Self {
+            impl<#lt_param> ::der::Decodable<#lifetime> for #ident<#lt_param> {
                 fn decode(decoder: &mut ::der::Decoder<#lifetime>) -> ::der::Result<Self> {
                     match decoder.peek_tag()? {
                         #decode_body
@@ -173,7 +169,7 @@ impl DeriveChoice {
                 }
             }
 
-            gen impl ::der::Encodable for @Self {
+            impl<#lt_param> ::der::Encodable for #ident<#lt_param> {
                 fn encode(&self, encoder: &mut ::der::Encoder<'_>) -> ::der::Result<()> {
                     match self {
                         #encode_body
@@ -187,13 +183,13 @@ impl DeriveChoice {
                 }
             }
 
-            gen impl ::der::Tagged for @Self {
+            impl<#lt_param> ::der::Tagged for #ident<#lt_param> {
                 fn tag(&self) -> ::der::Tag {
                     match self {
                         #tagged_body
                     }
                 }
             }
-        })
+        }
     }
 }

der/derive/src/choice.rs

@@ -5,14 +5,16 @@
 use crate::ATTR_NAME;
 use proc_macro2::TokenStream;
 use quote::{quote, ToTokens};
-use syn::{DataEnum, Expr, ExprLit, Ident, Lit, LitInt};
-use synstructure::Structure;
+use syn::{Attribute, DataEnum, Expr, ExprLit, Ident, Lit, LitInt};
 
 /// Valid options for the `#[repr]` attribute on `Enumerated` types.
 const REPR_TYPES: &[&str] = &["u8", "u16", "u32"];
 
 /// Derive the `Enumerated` trait for an enum.
 pub(crate) struct DeriveEnumerated {
+    /// Name of the enum type.
+    ident: Ident,
+
     /// Value of the `repr` attribute.
     repr: Ident,
 
@@ -22,16 +24,10 @@ pub(crate) struct DeriveEnumerated {
 
 impl DeriveEnumerated {
     /// Derive `Decodable` on an enum.
-    pub fn derive(s: Structure<'_>, data: &DataEnum) -> TokenStream {
-        assert_eq!(
-            s.variants().len(),
-            data.variants.len(),
-            "enum variant count mismatch"
-        );
-
+    pub fn derive(ident: Ident, data: DataEnum, attrs: &[Attribute]) -> TokenStream {
         // Reject `asn1` attributes, parse the `repr` attribute
         let mut repr: Option<Ident> = None;
-        for attr in &s.ast().attrs {
+        for attr in attrs {
             if attr.path.is_ident(ATTR_NAME) {
                 panic!("`asn1` attribute is not allowed on `Enumerated` types");
             } else if attr.path.is_ident("repr") {
@@ -78,6 +74,7 @@ impl DeriveEnumerated {
         }
 
         Self {
+            ident,
             repr: repr.unwrap_or_else(|| {
                 panic!(
                     "no `#[repr]` attribute on enum: must be one of {:?}",
@@ -86,20 +83,20 @@ impl DeriveEnumerated {
             }),
             variants,
         }
-        .finish(s)
+        .to_tokens()
     }
 
-    /// Finish deriving an enum
-    fn finish(self, s: Structure<'_>) -> TokenStream {
-        let repr = self.repr;
-
+    /// Lower the derived output into a [`TokenStream`].
+    fn to_tokens(&self) -> TokenStream {
         let mut try_from_body = TokenStream::new();
         for (ident, discriminant) in &self.variants {
             { quote!(#discriminant => Ok(Self::#ident),) }.to_tokens(&mut try_from_body);
         }
 
-        s.gen_impl(quote! {
-            gen impl ::der::DecodeValue<'static> for @Self {
+        let Self { ident, repr, .. } = self;
+
+        quote! {
+            impl ::der::DecodeValue<'static> for #ident {
                 fn decode_value(
                     decoder: &mut ::der::Decoder<'_>,
                     length: ::der::Length
@@ -108,7 +105,7 @@ impl DeriveEnumerated {
                 }
             }
 
-            gen impl ::der::EncodeValue for @Self {
+            impl ::der::EncodeValue for #ident {
                 fn value_len(&self) -> ::der::Result<::der::Length> {
                     ::der::EncodeValue::value_len(&(*self as #repr))
                 }
@@ -118,11 +115,11 @@ impl DeriveEnumerated {
                 }
             }
 
-            gen impl ::der::FixedTag for @Self {
+            impl ::der::FixedTag for #ident {
                 const TAG: ::der::Tag = ::der::Tag::Enumerated;
             }
 
-            gen impl TryFrom<#repr> for @Self {
+            impl TryFrom<#repr> for #ident {
                 type Error = ::der::Error;
 
                 fn try_from(n: #repr) -> ::der::Result<Self> {
@@ -132,6 +129,6 @@ impl DeriveEnumerated {
                     }
                 }
             }
-        })
+        }
     }
 }