Clean up the borrow crimes

derive/src/derive_enum.rs

@@ -66,28 +66,32 @@ impl DeriveEnum {
 
         let (mut impl_generics, ty_generics, where_clause) = generics.split_for_impl();
 
-        // check if we don't already have a '__de lifetime
+        // check if the type has lifetimes
-        let mut should_insert_lifetime = true;
+        let mut should_insert_lifetime = false;
 
         for param in &generics.params {
-            if let GenericParam::Lifetime(lt) = param {
+            if let GenericParam::Lifetime(_) = param {
-                if lt.lifetime.ident == "__de" {
+                should_insert_lifetime = true;
-                    should_insert_lifetime = false;
                 break;
             }
         }
-        }
 
         // if we don't have a '__de lifetime, insert it
         let mut generics_with_decode_lifetime;
         if should_insert_lifetime {
             generics_with_decode_lifetime = generics.clone();
+
+            let mut new_lifetime = LifetimeDef::new(Lifetime::new("'__de", Span::call_site()));
+
+            for param in &generics.params {
+                if let GenericParam::Lifetime(lt) = param {
+                    new_lifetime.bounds.push(lt.lifetime.clone())
+                }
+            }
+
             generics_with_decode_lifetime
                 .params
-                .push(GenericParam::Lifetime(LifetimeDef::new(Lifetime::new(
+                .push(GenericParam::Lifetime(new_lifetime));
-                    "'__de",
-                    Span::call_site(),
-                ))));
 
             impl_generics = generics_with_decode_lifetime.split_for_impl().0;
         }
@@ -95,8 +99,10 @@ impl DeriveEnum {
         let max_variant = (variants.len() - 1) as u32;
         let match_arms = variants.iter().enumerate().map(|(index, variant)| {
             let index = index as u32;
-            let decode_statements =
+            let decode_statements = field_names_to_decodable(
-                field_names_to_decodable(&fields_to_constructable_names(&variant.fields));
+                &fields_to_constructable_names(&variant.fields),
+                should_insert_lifetime,
+            );
             let variant_name = variant.ident.clone();
             quote! {
                 #index => {
@@ -106,9 +112,10 @@ impl DeriveEnum {
                 }
             }
         });
-        let result = quote! {
+        let result = if should_insert_lifetime {
-            impl #impl_generics bincode::de::Decodable<'__de> for #name #ty_generics #where_clause {
+            quote! {
-                fn decode<D: bincode::de::Decode<'__de>>(mut decoder: D) -> Result<#name #ty_generics, bincode::error::DecodeError> {
+                impl #impl_generics bincode::de::BorrowDecodable<'__de> for #name #ty_generics #where_clause {
+                    fn borrow_decode<D: bincode::de::BorrowDecode<'__de>>(mut decoder: D) -> Result<Self, bincode::error::DecodeError> {
                         let i = decoder.decode_u32()?;
                         Ok(match i {
                             #(#match_arms)*
@@ -121,6 +128,24 @@ impl DeriveEnum {
                     }
 
                 }
+            }
+        } else {
+            quote! {
+                impl #impl_generics bincode::de::Decodable for #name #ty_generics #where_clause {
+                    fn decode<D: bincode::de::Decode>(mut decoder: D) -> Result<Self, bincode::error::DecodeError> {
+                        let i = decoder.decode_u32()?;
+                        Ok(match i {
+                            #(#match_arms)*
+                            variant => return Err(bincode::error::DecodeError::UnexpectedVariant{
+                                min: 0,
+                                max: #max_variant,
+                                found: variant,
+                            })
+                        })
+                    }
+
+                }
+            }
         };
 
         Ok(result.into())
@@ -199,13 +224,19 @@ fn fields_to_constructable_names(fields: &Fields) -> Vec<TokenStream2> {
     }
 }
 
-fn field_names_to_decodable(names: &[TokenStream2]) -> Vec<TokenStream2> {
+fn field_names_to_decodable(names: &[TokenStream2], borrowed: bool) -> Vec<TokenStream2> {
     names
         .iter()
         .map(|field| {
+            if borrowed {
+                quote! {
+                    #field: bincode::de::BorrowDecodable::borrow_decode(&mut decoder)?,
+                }
+            } else {
                 quote! {
                     #field: bincode::de::Decodable::decode(&mut decoder)?,
                 }
+            }
         })
         .collect::<Vec<_>>()
 }

derive/src/derive_struct.rs

@@ -26,6 +26,7 @@ impl DeriveStruct {
                 .collect(),
             syn::Fields::Unit => Vec::new(),
         };
+
         Ok(Self {
             name,
             generics,
@@ -72,28 +73,30 @@ impl DeriveStruct {
 
         let (mut impl_generics, ty_generics, where_clause) = generics.split_for_impl();
 
-        // check if we don't already have a '__de lifetime
+        // check if the type has lifetimes
-        let mut should_insert_lifetime = true;
+        let mut should_insert_lifetime = false;
 
         for param in &generics.params {
-            if let GenericParam::Lifetime(lt) = param {
+            if let GenericParam::Lifetime(_) = param {
-                if lt.lifetime.ident == "__de" {
+                should_insert_lifetime = true;
-                    should_insert_lifetime = false;
                 break;
             }
         }
-        }
 
-        // if we don't have a '__de lifetime, insert it
+        // if the type has lifetimes, insert '__de and bound it to the lifetimes
         let mut generics_with_decode_lifetime;
         if should_insert_lifetime {
             generics_with_decode_lifetime = generics.clone();
+            let mut new_lifetime = LifetimeDef::new(Lifetime::new("'__de", Span::call_site()));
+
+            for param in &generics.params {
+                if let GenericParam::Lifetime(lt) = param {
+                    new_lifetime.bounds.push(lt.lifetime.clone())
+                }
+            }
             generics_with_decode_lifetime
                 .params
-                .push(GenericParam::Lifetime(LifetimeDef::new(Lifetime::new(
+                .push(GenericParam::Lifetime(new_lifetime));
-                    "'__de",
-                    Span::call_site(),
-                ))));
 
             impl_generics = generics_with_decode_lifetime.split_for_impl().0;
         }
@@ -101,21 +104,40 @@ impl DeriveStruct {
         let fields = fields
             .into_iter()
             .map(|field| {
+                if should_insert_lifetime {
+                    quote! {
+                        #field: bincode::de::BorrowDecodable::borrow_decode(&mut decoder)?,
+                    }
+                } else {
                     quote! {
                         #field: bincode::de::Decodable::decode(&mut decoder)?,
                     }
+                }
             })
             .collect::<Vec<_>>();
 
-        let result = quote! {
+        let result = if should_insert_lifetime {
-            impl #impl_generics bincode::de::Decodable< '__de > for #name #ty_generics #where_clause {
+            quote! {
-                fn decode<D: bincode::de::Decode< '__de >>(mut decoder: D) -> Result<Self, bincode::error::DecodeError> {
+                impl #impl_generics bincode::de::BorrowDecodable<'__de> for #name #ty_generics #where_clause {
+                    fn borrow_decode<D: bincode::de::BorrowDecode<'__de>>(mut decoder: D) -> Result<Self, bincode::error::DecodeError> {
                         Ok(#name {
                             #(#fields)*
                         })
                     }
 
                 }
+            }
+        } else {
+            quote! {
+                impl #impl_generics bincode::de::Decodable for #name #ty_generics #where_clause {
+                    fn decode<D: bincode::de::Decode>(mut decoder: D) -> Result<Self, bincode::error::DecodeError> {
+                        Ok(#name {
+                            #(#fields)*
+                        })
+                    }
+
+                }
+            }
         };
 
         Ok(result.into())

src/de/decoder.rs

@@ -32,7 +32,7 @@ impl<'a, 'de, R: BorrowReader<'de>, C: Config> BorrowDecode<'de> for &'a mut Dec
     }
 }
 
-impl<'a, 'de, R: Reader<'de>, C: Config> Decode<'de> for &'a mut Decoder<R, C> {
+impl<'a, 'de, R: Reader<'de>, C: Config> Decode for &'a mut Decoder<R, C> {
     fn decode_u8(&mut self) -> Result<u8, DecodeError> {
         let mut bytes = [0u8; 1];
         self.reader.read(&mut bytes)?;

src/de/impls.rs

@@ -1,86 +1,86 @@
 use super::{BorrowDecodable, BorrowDecode, Decodable, Decode};
 use crate::error::DecodeError;
 
-impl<'de> Decodable<'de> for u8 {
+impl<'de> Decodable for u8 {
-    fn decode<D: Decode<'de>>(mut decoder: D) -> Result<Self, DecodeError> {
+    fn decode<D: Decode>(mut decoder: D) -> Result<Self, DecodeError> {
         decoder.decode_u8()
     }
 }
 
-impl<'de> Decodable<'de> for u16 {
+impl<'de> Decodable for u16 {
-    fn decode<D: Decode<'de>>(mut decoder: D) -> Result<Self, DecodeError> {
+    fn decode<D: Decode>(mut decoder: D) -> Result<Self, DecodeError> {
         decoder.decode_u16()
     }
 }
 
-impl<'de> Decodable<'de> for u32 {
+impl<'de> Decodable for u32 {
-    fn decode<D: Decode<'de>>(mut decoder: D) -> Result<Self, DecodeError> {
+    fn decode<D: Decode>(mut decoder: D) -> Result<Self, DecodeError> {
         decoder.decode_u32()
     }
 }
 
-impl<'de> Decodable<'de> for u64 {
+impl<'de> Decodable for u64 {
-    fn decode<D: Decode<'de>>(mut decoder: D) -> Result<Self, DecodeError> {
+    fn decode<D: Decode>(mut decoder: D) -> Result<Self, DecodeError> {
         decoder.decode_u64()
     }
 }
 
-impl<'de> Decodable<'de> for u128 {
+impl<'de> Decodable for u128 {
-    fn decode<D: Decode<'de>>(mut decoder: D) -> Result<Self, DecodeError> {
+    fn decode<D: Decode>(mut decoder: D) -> Result<Self, DecodeError> {
         decoder.decode_u128()
     }
 }
 
-impl<'de> Decodable<'de> for usize {
+impl<'de> Decodable for usize {
-    fn decode<D: Decode<'de>>(mut decoder: D) -> Result<Self, DecodeError> {
+    fn decode<D: Decode>(mut decoder: D) -> Result<Self, DecodeError> {
         decoder.decode_usize()
     }
 }
 
-impl<'de> Decodable<'de> for i8 {
+impl<'de> Decodable for i8 {
-    fn decode<D: Decode<'de>>(mut decoder: D) -> Result<Self, DecodeError> {
+    fn decode<D: Decode>(mut decoder: D) -> Result<Self, DecodeError> {
         decoder.decode_i8()
     }
 }
 
-impl<'de> Decodable<'de> for i16 {
+impl<'de> Decodable for i16 {
-    fn decode<D: Decode<'de>>(mut decoder: D) -> Result<Self, DecodeError> {
+    fn decode<D: Decode>(mut decoder: D) -> Result<Self, DecodeError> {
         decoder.decode_i16()
     }
 }
 
-impl<'de> Decodable<'de> for i32 {
+impl<'de> Decodable for i32 {
-    fn decode<D: Decode<'de>>(mut decoder: D) -> Result<Self, DecodeError> {
+    fn decode<D: Decode>(mut decoder: D) -> Result<Self, DecodeError> {
         decoder.decode_i32()
     }
 }
 
-impl<'de> Decodable<'de> for i64 {
+impl<'de> Decodable for i64 {
-    fn decode<D: Decode<'de>>(mut decoder: D) -> Result<Self, DecodeError> {
+    fn decode<D: Decode>(mut decoder: D) -> Result<Self, DecodeError> {
         decoder.decode_i64()
     }
 }
 
-impl<'de> Decodable<'de> for i128 {
+impl<'de> Decodable for i128 {
-    fn decode<D: Decode<'de>>(mut decoder: D) -> Result<Self, DecodeError> {
+    fn decode<D: Decode>(mut decoder: D) -> Result<Self, DecodeError> {
         decoder.decode_i128()
     }
 }
 
-impl<'de> Decodable<'de> for isize {
+impl<'de> Decodable for isize {
-    fn decode<D: Decode<'de>>(mut decoder: D) -> Result<Self, DecodeError> {
+    fn decode<D: Decode>(mut decoder: D) -> Result<Self, DecodeError> {
         decoder.decode_isize()
     }
 }
 
-impl<'de> Decodable<'de> for f32 {
+impl<'de> Decodable for f32 {
-    fn decode<D: Decode<'de>>(mut decoder: D) -> Result<Self, DecodeError> {
+    fn decode<D: Decode>(mut decoder: D) -> Result<Self, DecodeError> {
         decoder.decode_f32()
     }
 }
 
-impl<'de> Decodable<'de> for f64 {
+impl<'de> Decodable for f64 {
-    fn decode<D: Decode<'de>>(mut decoder: D) -> Result<Self, DecodeError> {
+    fn decode<D: Decode>(mut decoder: D) -> Result<Self, DecodeError> {
         decoder.decode_f64()
     }
 }
@@ -99,21 +99,21 @@ impl<'a, 'de: 'a> BorrowDecodable<'de> for &'a str {
     }
 }
 
-impl<'de, const N: usize> Decodable<'de> for [u8; N] {
+impl<'de, const N: usize> Decodable for [u8; N] {
-    fn decode<D: Decode<'de>>(mut decoder: D) -> Result<Self, DecodeError> {
+    fn decode<D: Decode>(mut decoder: D) -> Result<Self, DecodeError> {
         decoder.decode_array()
     }
 }
 
-impl<'de, T> Decodable<'de> for core::marker::PhantomData<T> {
+impl<'de, T> Decodable for core::marker::PhantomData<T> {
-    fn decode<D: Decode<'de>>(_: D) -> Result<Self, DecodeError> {
+    fn decode<D: Decode>(_: D) -> Result<Self, DecodeError> {
         Ok(core::marker::PhantomData)
     }
 }
 
-impl<'a, 'de, T> Decode<'de> for &'a mut T
+impl<'a, 'de, T> Decode for &'a mut T
 where
-    T: Decode<'de>,
+    T: Decode,
 {
     fn decode_u8(&mut self) -> Result<u8, DecodeError> {
         T::decode_u8(self)
@@ -175,3 +175,12 @@ where
         T::decode_array::<N>(self)
     }
 }
+
+impl<'a, 'de, T> BorrowDecode<'de> for &'a mut T
+where
+    T: BorrowDecode<'de>,
+{
+    fn decode_slice(&mut self, len: usize) -> Result<&'de [u8], DecodeError> {
+        T::decode_slice(self, len)
+    }
+}

src/de/mod.rs

@@ -6,21 +6,21 @@ mod impls;
 pub mod read;
 pub use self::decoder::Decoder;
 
-pub trait Decodable<'de>: Sized + BorrowDecodable<'de> {
+pub trait Decodable: for<'de> BorrowDecodable<'de> {
-    fn decode<D: Decode<'de>>(decoder: D) -> Result<Self, DecodeError>;
+    fn decode<D: Decode>(decoder: D) -> Result<Self, DecodeError>;
 }
 
 pub trait BorrowDecodable<'de>: Sized {
     fn borrow_decode<D: BorrowDecode<'de>>(decoder: D) -> Result<Self, DecodeError>;
 }
 
-impl<'de, T: Decodable<'de>> BorrowDecodable<'de> for T {
+impl<'de, T: Decodable> BorrowDecodable<'de> for T {
-    fn borrow_decode<D: Decode<'de>>(decoder: D) -> Result<Self, DecodeError> {
+    fn borrow_decode<D: Decode>(decoder: D) -> Result<Self, DecodeError> {
         Decodable::decode(decoder)
     }
 }
 
-pub trait Decode<'de> {
+pub trait Decode {
     fn decode_u8(&mut self) -> Result<u8, DecodeError>;
     fn decode_u16(&mut self) -> Result<u16, DecodeError>;
     fn decode_u32(&mut self) -> Result<u32, DecodeError>;
@@ -40,6 +40,6 @@ pub trait Decode<'de> {
     fn decode_array<const N: usize>(&mut self) -> Result<[u8; N], DecodeError>;
 }
 
-pub trait BorrowDecode<'de>: Decode<'de> {
+pub trait BorrowDecode<'de>: Decode {
     fn decode_slice(&mut self, len: usize) -> Result<&'de [u8], DecodeError>;
 }

src/features/impl_std.rs

@@ -4,13 +4,13 @@ use crate::{
     error::DecodeError,
 };
 
-pub fn decode_from<'__de, D: Decodable<'__de>, R: std::io::Read>(
+pub fn decode_from<'__de, D: Decodable, R: std::io::Read>(
     src: &'__de mut R,
 ) -> Result<D, DecodeError> {
     decode_from_with_config(src, config::Default)
 }
 
-pub fn decode_from_with_config<'__de, D: Decodable<'__de>, C: Config, R: std::io::Read>(
+pub fn decode_from_with_config<'__de, D: Decodable, C: Config, R: std::io::Read>(
     src: &'__de mut R,
     _config: C,
 ) -> Result<D, DecodeError> {

tests/derive.rs

@@ -1,7 +1,6 @@
 #![cfg(feature = "derive")]
 
 use bincode::{de::Decodable, enc::Encodeable};
-use core::marker::PhantomData;
 
 #[derive(bincode::Encodable, PartialEq, Debug)]
 pub struct Test<T: Encodeable> {
@@ -11,11 +10,17 @@ pub struct Test<T: Encodeable> {
 }
 
 #[derive(bincode::Decodable, PartialEq, Debug, Eq)]
-pub struct Test2<'__de, T: Decodable<'__de>> {
+pub struct Test2<T: Decodable> {
     a: T,
     b: u32,
     c: u32,
-    pd: PhantomData<&'__de ()>,
+}
+
+#[derive(bincode::Decodable, PartialEq, Debug, Eq)]
+pub struct Test3<'a> {
+    a: &'a str,
+    b: u32,
+    c: u32,
 }
 
 #[derive(bincode::Encodable, bincode::Decodable, PartialEq, Debug, Eq)]
@@ -28,6 +33,13 @@ pub enum TestEnum {
     Baz(u32, u32, u32),
 }
 
+#[derive(bincode::Encodable, bincode::Decodable, PartialEq, Debug, Eq)]
+pub enum TestEnum2<'a> {
+    Foo,
+    Bar { name: &'a str },
+    Baz(u32, u32, u32),
+}
+
 #[test]
 fn test_encodable() {
     let start = Test {
@@ -47,10 +59,9 @@ fn test_decodable() {
         a: 5u32,
         b: 10u32,
         c: 1024u32,
-        pd: PhantomData,
     };
-    let mut slice = [5, 10, 251, 0, 4];
+    let slice = [5, 10, 251, 0, 4];
-    let result: Test2<u32> = bincode::decode(&mut slice).unwrap();
+    let result: Test2<u32> = bincode::decode_from(&mut slice.as_ref()).unwrap();
     assert_eq!(result, start);
 }
 

tests/test.rs

@@ -4,7 +4,7 @@ use core::fmt::Debug;
 fn the_same_with_config<V, C>(element: V, config: C)
 where
     V: bincode::enc::Encodeable
-        + for<'de> bincode::de::Decodable<'de>
+        + for<'de> bincode::de::Decodable
         + PartialEq
         + Debug
         + Clone
@@ -20,7 +20,7 @@ where
 fn the_same<V>(element: V)
 where
     V: bincode::enc::Encodeable
-        + for<'de> bincode::de::Decodable<'de>
+        + for<'de> bincode::de::Decodable
         + PartialEq
         + Debug
         + Clone