der_derive: handle type generics in sequence

Author: baloo

der/derive/src/choice.rs

@@ -61,7 +61,10 @@ impl DeriveChoice {
 
         let lifetime = match self.lifetime {
             Some(ref lifetime) => quote!(#lifetime),
-            None => default_lifetime(),
+            None => {
+                let lifetime = default_lifetime();
+                quote!(#lifetime)
+            }
         };
 
         // Lifetime parameters

der/derive/src/lib.rs

@@ -141,13 +141,11 @@ use crate::{
 use proc_macro::TokenStream;
 use proc_macro2::Span;
 use proc_macro_error::proc_macro_error;
-use quote::quote;
 use syn::{parse_macro_input, DeriveInput, Lifetime};
 
 /// Get the default lifetime.
-fn default_lifetime() -> proc_macro2::TokenStream {
-    let lifetime = Lifetime::new("'__der_lifetime", Span::call_site());
-    quote!(#lifetime)
+fn default_lifetime() -> Lifetime {
+    Lifetime::new("'__der_lifetime", Span::call_site())
 }
 
 /// Derive the [`Choice`][1] trait on an `enum`.

der/derive/src/sequence.rs

@@ -8,15 +8,15 @@ use field::SequenceField;
 use proc_macro2::TokenStream;
 use proc_macro_error::abort;
 use quote::quote;
-use syn::{DeriveInput, Ident, Lifetime};
+use syn::{DeriveInput, GenericParam, Generics, Ident, Lifetime, LifetimeParam};
 
 /// Derive the `Sequence` trait for a struct
 pub(crate) struct DeriveSequence {
     /// Name of the sequence struct.
     ident: Ident,
 
-    /// Lifetime of the struct.
-    lifetime: Option<Lifetime>,
+    /// Generics of the struct.
+    generics: Generics,
 
     /// Fields of the struct.
     fields: Vec<SequenceField>,
@@ -33,13 +33,6 @@ impl DeriveSequence {
             ),
         };
 
-        // TODO(tarcieri): properly handle multiple lifetimes
-        let lifetime = input
-            .generics
-            .lifetimes()
-            .next()
-            .map(|lt| lt.lifetime.clone());
-
         let type_attrs = TypeAttrs::parse(&input.attrs);
 
         let fields = data
@@ -50,27 +43,33 @@ impl DeriveSequence {
 
         Self {
             ident: input.ident,
-            lifetime,
+            //    lifetime,
+            generics: input.generics.clone(),
             fields,
         }
     }
 
     /// Lower the derived output into a [`TokenStream`].
     pub fn to_tokens(&self) -> TokenStream {
         let ident = &self.ident;
-
-        let lifetime = match self.lifetime {
-            Some(ref lifetime) => quote!(#lifetime),
-            None => default_lifetime(),
+        let mut generics = self.generics.clone();
+
+        // Use the first lifetime parameter as lifetime for Decode/Encode lifetime
+        // if none found, add one.
+        let lifetime: Lifetime = if let Some(lt) = generics.lifetimes().next() {
+            lt.lifetime.clone()
+        } else {
+            let lifetime = default_lifetime();
+            generics.params.insert(
+                0,
+                GenericParam::Lifetime(LifetimeParam::new(lifetime.clone())),
+            );
+            lifetime
         };
 
-        // Lifetime parameters
-        // TODO(tarcieri): support multiple lifetimes
-        let lt_params = self
-            .lifetime
-            .as_ref()
-            .map(|_| lifetime.clone())
-            .unwrap_or_default();
+        // We may or may not have inserted a lifetime.
+        let (_impl_generics, ty_generics, where_clause) = self.generics.split_for_impl();
+        let (impl_generics, _ty_generics, _where_clause) = generics.split_for_impl();
 
         let mut decode_body = Vec::new();
         let mut decode_result = Vec::new();
@@ -87,7 +86,7 @@ impl DeriveSequence {
         }
 
         quote! {
-            impl<#lifetime> ::der::DecodeValue<#lifetime> for #ident<#lt_params> {
+            impl #impl_generics ::der::DecodeValue<#lifetime> for #ident #ty_generics #where_clause {
                 fn decode_value<R: ::der::Reader<#lifetime>>(
                     reader: &mut R,
                     header: ::der::Header,
@@ -104,7 +103,7 @@ impl DeriveSequence {
                 }
             }
 
-            impl<#lifetime> ::der::EncodeValue for #ident<#lt_params> {
+            impl #impl_generics ::der::EncodeValue for #ident #ty_generics #where_clause {
                 fn value_len(&self) -> ::der::Result<::der::Length> {
                     use ::der::Encode as _;
 
@@ -122,7 +121,7 @@ impl DeriveSequence {
                 }
             }
 
-            impl<#lifetime> ::der::Sequence<#lifetime> for #ident<#lt_params> {}
+            impl #impl_generics ::der::Sequence<#lifetime> for #ident #ty_generics #where_clause {}
         }
     }
 }