Make DeserializeInner unsafe to implement due to the new covariance constraint on its DeserType

progval · progval · commit 3c96b728227a · 2025-08-08T10:26:37.000+02:00
diff --git a/epserde-derive/src/lib.rs b/epserde-derive/src/lib.rs
@@ -484,8 +484,9 @@ pub fn epserde_derive(input: TokenStream) -> TokenStream {
                         }
                     }
 
+                    // SAFETY: &'epserde_desertype Self is covariant
                     #[automatically_derived]
-                    impl<#generics_deserialize> epserde::deser::DeserializeInner for #name<#concat_generics> #where_clause_des
+                    unsafe impl<#generics_deserialize> epserde::deser::DeserializeInner for #name<#concat_generics> #where_clause_des
                     {
                         unsafe fn _deserialize_full_inner(
                             backend: &mut impl epserde::deser::ReadWithPos,
@@ -540,8 +541,9 @@ pub fn epserde_derive(input: TokenStream) -> TokenStream {
                         }
                     }
 
+                    // SAFETY: #name is a struct, so it is covariant
                     #[automatically_derived]
-                    impl<#generics_deserialize> epserde::deser::DeserializeInner for #name<#concat_generics> #where_clause_des {
+                    unsafe impl<#generics_deserialize> epserde::deser::DeserializeInner for #name<#concat_generics> #where_clause_des {
                         unsafe fn _deserialize_full_inner(
                             backend: &mut impl epserde::deser::ReadWithPos,
                         ) -> core::result::Result<Self, epserde::deser::Error> {
@@ -824,8 +826,9 @@ pub fn epserde_derive(input: TokenStream) -> TokenStream {
                         }
                     }
 
+                    // SAFETY: &'epserde_desertype Self is covariant
                     #[automatically_derived]
-                    impl<#generics_deserialize> epserde::deser::DeserializeInner for #name<#concat_generics> #where_clause_des {
+                    unsafe impl<#generics_deserialize> epserde::deser::DeserializeInner for #name<#concat_generics> #where_clause_des {
                         unsafe fn _deserialize_full_inner(
                             backend: &mut impl epserde::deser::ReadWithPos,
                         ) -> core::result::Result<Self, epserde::deser::Error> {
@@ -878,8 +881,9 @@ pub fn epserde_derive(input: TokenStream) -> TokenStream {
                             Ok(())
                         }
                     }
+                    // SAFETY: #name is an enum, so it is covariant
                     #[automatically_derived]
-                    impl<#generics_deserialize> epserde::deser::DeserializeInner for #name<#concat_generics> #where_clause_des {
+                    unsafe impl<#generics_deserialize> epserde::deser::DeserializeInner for #name<#concat_generics> #where_clause_des {
                         unsafe fn _deserialize_full_inner(
                             backend: &mut impl epserde::deser::ReadWithPos,
                         ) -> core::result::Result<Self, epserde::deser::Error> {
diff --git a/epserde/src/deser/mem_case.rs b/epserde/src/deser/mem_case.rs
@@ -139,7 +139,6 @@ impl<'a, S: DeserializeInner> MemCase<'a, S> {
     pub fn borrow<'this>(&'this self) -> &'this <S as DeserializeInner>::DeserType<'this> {
         // SAFETY: 'a outlives 'this, and <S as DeserializeInner>::DeserType is required to be
         // covariant (ie. it's a normal structure and not, say, a closure with 'this as argument)
-        // TODO: document in DeserializeInner that its DeserType must be covariant
         unsafe {
             core::mem::transmute::<
                 &'this <S as DeserializeInner>::DeserType<'a>,
diff --git a/epserde/src/deser/mod.rs b/epserde/src/deser/mod.rs
@@ -64,6 +64,8 @@ pub type DeserType<'a, T> = <T as DeserializeInner>::DeserType<'a>;
 ///   incompatible structures using the same code, or cause undefined behavior
 ///   by loading data with an incorrect alignment.
 /// - Memory-mapped files might be modified externally.
+/// - [`Self::DeserType`] must be covariant (ie. behave like a structure,
+///   not a closure with a generic argument)
 pub trait Deserialize: DeserializeInner {
     /// Fully deserialize a structure of this type from the given backend.
     ///
@@ -253,7 +255,11 @@ pub trait Deserialize: DeserializeInner {
 /// the user from modifying the methods in [`Deserialize`].
 ///
 /// The user should not implement this trait directly, but rather derive it.
-pub trait DeserializeInner: Sized {
+///
+/// # Safety
+///
+/// See [`Deserialize`]
+pub unsafe trait DeserializeInner: Sized {
     /// The deserialization type associated with this type. It can be
     /// retrieved conveniently with the alias [`DeserType`].
     type DeserType<'a>;
diff --git a/epserde/src/impls/array.rs b/epserde/src/impls/array.rs
@@ -75,7 +75,7 @@ impl<T: DeepCopy + SerializeInner, const N: usize> SerializeHelper<Deep> for [T;
     }
 }
 
-impl<T: CopyType + DeserializeInner, const N: usize> DeserializeInner for [T; N]
+unsafe impl<T: CopyType + DeserializeInner, const N: usize> DeserializeInner for [T; N]
 where
     [T; N]: DeserializeHelper<<T as CopyType>::Copy, FullType = [T; N]>,
 {
diff --git a/epserde/src/impls/boxed_slice.rs b/epserde/src/impls/boxed_slice.rs
@@ -60,7 +60,7 @@ impl<T: DeepCopy + SerializeInner> SerializeHelper<Deep> for Box<[T]> {
 }
 
 // This delegates to a private helper trait which we can specialize on in stable rust
-impl<T: DeserializeInner + CopyType> DeserializeInner for Box<[T]>
+unsafe impl<T: DeserializeInner + CopyType> DeserializeInner for Box<[T]>
 where
     Box<[T]>: DeserializeHelper<<T as CopyType>::Copy, FullType = Box<[T]>>,
 {
diff --git a/epserde/src/impls/prim.rs b/epserde/src/impls/prim.rs
@@ -67,7 +67,7 @@ macro_rules! impl_prim_ser_des {
             }
         }
 
-		impl DeserializeInner for $ty {
+		unsafe impl DeserializeInner for $ty {
             #[inline(always)]
             unsafe fn _deserialize_full_inner(backend: &mut impl ReadWithPos) -> deser::Result<$ty> {
                 let mut buf = [0; size_of::<$ty>()];
@@ -109,7 +109,7 @@ macro_rules! impl_nonzero_ser_des {
             }
         }
 
-		impl DeserializeInner for $ty {
+		unsafe impl DeserializeInner for $ty {
             #[inline(always)]
             unsafe fn _deserialize_full_inner(backend: &mut impl ReadWithPos) -> deser::Result<$ty> {
                 let mut buf = [0; size_of::<$ty>()];
@@ -179,7 +179,7 @@ impl SerializeInner for bool {
     }
 }
 
-impl DeserializeInner for bool {
+unsafe impl DeserializeInner for bool {
     #[inline(always)]
     unsafe fn _deserialize_full_inner(backend: &mut impl ReadWithPos) -> deser::Result<bool> {
         Ok(u8::_deserialize_full_inner(backend)? != 0)
@@ -208,7 +208,7 @@ impl SerializeInner for char {
     }
 }
 
-impl DeserializeInner for char {
+unsafe impl DeserializeInner for char {
     #[inline(always)]
     unsafe fn _deserialize_full_inner(backend: &mut impl ReadWithPos) -> deser::Result<Self> {
         Ok(char::from_u32(u32::_deserialize_full_inner(backend)?).unwrap())
@@ -235,7 +235,7 @@ impl SerializeInner for () {
     }
 }
 
-impl DeserializeInner for () {
+unsafe impl DeserializeInner for () {
     #[inline(always)]
     unsafe fn _deserialize_full_inner(_backend: &mut impl ReadWithPos) -> deser::Result<Self> {
         Ok(())
@@ -288,7 +288,7 @@ impl<T: ?Sized> SerializeInner for PhantomData<T> {
     }
 }
 
-impl<T: ?Sized> DeserializeInner for PhantomData<T> {
+unsafe impl<T: ?Sized> DeserializeInner for PhantomData<T> {
     #[inline(always)]
     unsafe fn _deserialize_full_inner(_backend: &mut impl ReadWithPos) -> deser::Result<Self> {
         Ok(PhantomData::<T>)
@@ -339,7 +339,7 @@ impl<T: SerializeInner + TypeHash + AlignHash> SerializeInner for Option<T> {
     }
 }
 
-impl<T: DeserializeInner> DeserializeInner for Option<T> {
+unsafe impl<T: DeserializeInner> DeserializeInner for Option<T> {
     #[inline(always)]
     unsafe fn _deserialize_full_inner(backend: &mut impl ReadWithPos) -> deser::Result<Self> {
         let tag = u8::_deserialize_full_inner(backend)?;
diff --git a/epserde/src/impls/stdlib.rs b/epserde/src/impls/stdlib.rs
@@ -94,7 +94,7 @@ impl<Idx: ZeroCopy + SerializeInner + TypeHash + AlignHash> SerializeInner
     }
 }
 
-impl<Idx: ZeroCopy + DeserializeInner> DeserializeInner for core::ops::Range<Idx> {
+unsafe impl<Idx: ZeroCopy + DeserializeInner> DeserializeInner for core::ops::Range<Idx> {
     #[inline(always)]
     unsafe fn _deserialize_full_inner(backend: &mut impl ReadWithPos) -> deser::Result<Self> {
         let start = Idx::_deserialize_full_inner(backend)?;
@@ -126,7 +126,7 @@ impl<Idx: ZeroCopy + SerializeInner + TypeHash + AlignHash> SerializeInner
     }
 }
 
-impl<Idx: ZeroCopy + DeserializeInner> DeserializeInner for core::ops::RangeFrom<Idx> {
+unsafe impl<Idx: ZeroCopy + DeserializeInner> DeserializeInner for core::ops::RangeFrom<Idx> {
     #[inline(always)]
     unsafe fn _deserialize_full_inner(backend: &mut impl ReadWithPos) -> deser::Result<Self> {
         let start = Idx::_deserialize_full_inner(backend)?;
@@ -158,7 +158,7 @@ impl<Idx: ZeroCopy + SerializeInner + TypeHash + AlignHash> SerializeInner
     }
 }
 
-impl<Idx: ZeroCopy + DeserializeInner> DeserializeInner for core::ops::RangeInclusive<Idx> {
+unsafe impl<Idx: ZeroCopy + DeserializeInner> DeserializeInner for core::ops::RangeInclusive<Idx> {
     #[inline(always)]
     unsafe fn _deserialize_full_inner(backend: &mut impl ReadWithPos) -> deser::Result<Self> {
         let start = Idx::_deserialize_full_inner(backend)?;
@@ -194,7 +194,7 @@ impl<Idx: ZeroCopy + SerializeInner + TypeHash + AlignHash> SerializeInner
     }
 }
 
-impl<Idx: ZeroCopy + DeserializeInner> DeserializeInner for core::ops::RangeTo<Idx> {
+unsafe impl<Idx: ZeroCopy + DeserializeInner> DeserializeInner for core::ops::RangeTo<Idx> {
     #[inline(always)]
     unsafe fn _deserialize_full_inner(backend: &mut impl ReadWithPos) -> deser::Result<Self> {
         let end = Idx::_deserialize_full_inner(backend)?;
@@ -224,7 +224,7 @@ impl<Idx: ZeroCopy + SerializeInner + TypeHash + AlignHash> SerializeInner
     }
 }
 
-impl<Idx: ZeroCopy + DeserializeInner> DeserializeInner for core::ops::RangeToInclusive<Idx> {
+unsafe impl<Idx: ZeroCopy + DeserializeInner> DeserializeInner for core::ops::RangeToInclusive<Idx> {
     #[inline(always)]
     unsafe fn _deserialize_full_inner(backend: &mut impl ReadWithPos) -> deser::Result<Self> {
         let end = Idx::_deserialize_full_inner(backend)?;
@@ -251,7 +251,7 @@ impl SerializeInner for core::ops::RangeFull {
     }
 }
 
-impl DeserializeInner for core::ops::RangeFull {
+unsafe impl DeserializeInner for core::ops::RangeFull {
     #[inline(always)]
     unsafe fn _deserialize_full_inner(_backend: &mut impl ReadWithPos) -> deser::Result<Self> {
         Ok(core::ops::RangeFull)
@@ -301,7 +301,7 @@ impl<T: SerializeInner + TypeHash + AlignHash> SerializeInner for core::ops::Bou
     }
 }
 
-impl<T: DeserializeInner> DeserializeInner for core::ops::Bound<T> {
+unsafe impl<T: DeserializeInner> DeserializeInner for core::ops::Bound<T> {
     #[inline(always)]
     unsafe fn _deserialize_full_inner(backend: &mut impl ReadWithPos) -> deser::Result<Self> {
         let tag = u8::_deserialize_full_inner(backend)?;
@@ -376,7 +376,7 @@ impl<B: SerializeInner + TypeHash + AlignHash, C: SerializeInner + TypeHash + Al
     }
 }
 
-impl<B: DeserializeInner, C: DeserializeInner> DeserializeInner for core::ops::ControlFlow<B, C> {
+unsafe impl<B: DeserializeInner, C: DeserializeInner> DeserializeInner for core::ops::ControlFlow<B, C> {
     #[inline(always)]
     unsafe fn _deserialize_full_inner(backend: &mut impl ReadWithPos) -> deser::Result<Self> {
         let tag = u8::_deserialize_full_inner(backend)?;
diff --git a/epserde/src/impls/string.rs b/epserde/src/impls/string.rs
@@ -65,7 +65,7 @@ impl SerializeInner for String {
     }
 }
 
-impl DeserializeInner for String {
+unsafe impl DeserializeInner for String {
     unsafe fn _deserialize_full_inner(backend: &mut impl ReadWithPos) -> deser::Result<Self> {
         let slice = deserialize_full_vec_zero(backend)?;
         Ok(String::from_utf8(slice).unwrap())
@@ -99,7 +99,7 @@ impl SerializeInner for Box<str> {
     }
 }
 
-impl DeserializeInner for Box<str> {
+unsafe impl DeserializeInner for Box<str> {
     #[inline(always)]
     unsafe fn _deserialize_full_inner(backend: &mut impl ReadWithPos) -> deser::Result<Self> {
         Ok(String::_deserialize_full_inner(backend)?.into_boxed_str())
diff --git a/epserde/src/impls/tuple.rs b/epserde/src/impls/tuple.rs
@@ -87,7 +87,7 @@ macro_rules! impl_tuples {
             }
         }
 
-		impl<T: ZeroCopy + TypeHash + AlignHash> DeserializeInner for ($($t,)*) {
+		unsafe impl<T: ZeroCopy + TypeHash + AlignHash> DeserializeInner for ($($t,)*) {
             type DeserType<'a> = &'a ($($t,)*);
             unsafe fn _deserialize_full_inner(backend: &mut impl ReadWithPos) -> deser::Result<Self> {
                 deserialize_full_zero::<($($t,)*)>(backend)
diff --git a/epserde/src/impls/vec.rs b/epserde/src/impls/vec.rs
@@ -66,7 +66,7 @@ impl<T: DeepCopy + SerializeInner> SerializeHelper<Deep> for Vec<T> {
 }
 
 // This delegates to a private helper trait which we can specialize on in stable rust
-impl<T: CopyType + DeserializeInner> DeserializeInner for Vec<T>
+unsafe impl<T: CopyType + DeserializeInner> DeserializeInner for Vec<T>
 where
     Vec<T>: DeserializeHelper<<T as CopyType>::Copy, FullType = Vec<T>>,
 {
diff --git a/epserde/src/lib.rs b/epserde/src/lib.rs
@@ -147,7 +147,7 @@ impl<T: ?Sized> SerializeInner for PhantomDeserData<T> {
     }
 }
 
-impl<T: ?Sized + DeserializeInner> DeserializeInner for PhantomDeserData<T> {
+unsafe impl<T: ?Sized + DeserializeInner> DeserializeInner for PhantomDeserData<T> {
     #[inline(always)]
     unsafe fn _deserialize_full_inner(_backend: &mut impl ReadWithPos) -> deser::Result<Self> {
         Ok(PhantomDeserData(PhantomData))

Original file line number	Diff line number	Diff line change
`@@ -484,8 +484,9 @@ pub fn epserde_derive(input: TokenStream) -> TokenStream {`
`484`	`484`	`}`
`485`	`485`	`}`
`486`	`486`
	`487`	`+ // SAFETY: &'epserde_desertype Self is covariant`
`487`	`488`	`#[automatically_derived]`
`488`		`- impl<#generics_deserialize> epserde::deser::DeserializeInner for #name<#concat_generics> #where_clause_des`
	`489`	`+ unsafe impl<#generics_deserialize> epserde::deser::DeserializeInner for #name<#concat_generics> #where_clause_des`
`489`	`490`	`{`
`490`	`491`	`unsafe fn _deserialize_full_inner(`
`491`	`492`	`backend: &mut impl epserde::deser::ReadWithPos,`
`@@ -540,8 +541,9 @@ pub fn epserde_derive(input: TokenStream) -> TokenStream {`
`540`	`541`	`}`
`541`	`542`	`}`
`542`	`543`
	`544`	`+ // SAFETY: #name is a struct, so it is covariant`
`543`	`545`	`#[automatically_derived]`
`544`		`- impl<#generics_deserialize> epserde::deser::DeserializeInner for #name<#concat_generics> #where_clause_des {`
	`546`	`+ unsafe impl<#generics_deserialize> epserde::deser::DeserializeInner for #name<#concat_generics> #where_clause_des {`
`545`	`547`	`unsafe fn _deserialize_full_inner(`
`546`	`548`	`backend: &mut impl epserde::deser::ReadWithPos,`
`547`	`549`	`) -> core::result::Result<Self, epserde::deser::Error> {`
`@@ -824,8 +826,9 @@ pub fn epserde_derive(input: TokenStream) -> TokenStream {`
`824`	`826`	`}`
`825`	`827`	`}`
`826`	`828`
	`829`	`+ // SAFETY: &'epserde_desertype Self is covariant`
`827`	`830`	`#[automatically_derived]`
`828`		`- impl<#generics_deserialize> epserde::deser::DeserializeInner for #name<#concat_generics> #where_clause_des {`
	`831`	`+ unsafe impl<#generics_deserialize> epserde::deser::DeserializeInner for #name<#concat_generics> #where_clause_des {`
`829`	`832`	`unsafe fn _deserialize_full_inner(`
`830`	`833`	`backend: &mut impl epserde::deser::ReadWithPos,`
`831`	`834`	`) -> core::result::Result<Self, epserde::deser::Error> {`
`@@ -878,8 +881,9 @@ pub fn epserde_derive(input: TokenStream) -> TokenStream {`
`878`	`881`	`Ok(())`
`879`	`882`	`}`
`880`	`883`	`}`
	`884`	`+ // SAFETY: #name is an enum, so it is covariant`
`881`	`885`	`#[automatically_derived]`
`882`		`- impl<#generics_deserialize> epserde::deser::DeserializeInner for #name<#concat_generics> #where_clause_des {`
	`886`	`+ unsafe impl<#generics_deserialize> epserde::deser::DeserializeInner for #name<#concat_generics> #where_clause_des {`
`883`	`887`	`unsafe fn _deserialize_full_inner(`
`884`	`888`	`backend: &mut impl epserde::deser::ReadWithPos,`
`885`	`889`	`) -> core::result::Result<Self, epserde::deser::Error> {`
Original file line number	Diff line number	Diff line change
`@@ -75,7 +75,7 @@ impl<T: DeepCopy + SerializeInner, const N: usize> SerializeHelper<Deep> for [T;`
`75`	`75`	`}`
`76`	`76`	`}`
`77`	`77`
`78`		`-impl<T: CopyType + DeserializeInner, const N: usize> DeserializeInner for [T; N]`
	`78`	`+unsafe impl<T: CopyType + DeserializeInner, const N: usize> DeserializeInner for [T; N]`
`79`	`79`	`where`
`80`	`80`	`[T; N]: DeserializeHelper<<T as CopyType>::Copy, FullType = [T; N]>,`
`81`	`81`	`{`
Original file line number	Diff line number	Diff line change
`@@ -60,7 +60,7 @@ impl<T: DeepCopy + SerializeInner> SerializeHelper<Deep> for Box<[T]> {`
`60`	`60`	`}`
`61`	`61`
`62`	`62`	`// This delegates to a private helper trait which we can specialize on in stable rust`
`63`		`-impl<T: DeserializeInner + CopyType> DeserializeInner for Box<[T]>`
	`63`	`+unsafe impl<T: DeserializeInner + CopyType> DeserializeInner for Box<[T]>`
`64`	`64`	`where`
`65`	`65`	`Box<[T]>: DeserializeHelper<<T as CopyType>::Copy, FullType = Box<[T]>>,`
`66`	`66`	`{`
Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,7 @@ macro_rules! impl_prim_ser_des {`
`67`	`67`	`}`
`68`	`68`	`}`
`69`	`69`
`70`		`- impl DeserializeInner for $ty {`
	`70`	`+ unsafe impl DeserializeInner for $ty {`
`71`	`71`	`#[inline(always)]`
`72`	`72`	`unsafe fn _deserialize_full_inner(backend: &mut impl ReadWithPos) -> deser::Result<$ty> {`
`73`	`73`	`let mut buf = [0; size_of::<$ty>()];`
`@@ -109,7 +109,7 @@ macro_rules! impl_nonzero_ser_des {`
`109`	`109`	`}`
`110`	`110`	`}`
`111`	`111`
`112`		`- impl DeserializeInner for $ty {`
	`112`	`+ unsafe impl DeserializeInner for $ty {`
`113`	`113`	`#[inline(always)]`
`114`	`114`	`unsafe fn _deserialize_full_inner(backend: &mut impl ReadWithPos) -> deser::Result<$ty> {`
`115`	`115`	`let mut buf = [0; size_of::<$ty>()];`
`@@ -179,7 +179,7 @@ impl SerializeInner for bool {`
`179`	`179`	`}`
`180`	`180`	`}`
`181`	`181`
`182`		`-impl DeserializeInner for bool {`
	`182`	`+unsafe impl DeserializeInner for bool {`
`183`	`183`	`#[inline(always)]`
`184`	`184`	`unsafe fn _deserialize_full_inner(backend: &mut impl ReadWithPos) -> deser::Result<bool> {`
`185`	`185`	`Ok(u8::_deserialize_full_inner(backend)? != 0)`
`@@ -208,7 +208,7 @@ impl SerializeInner for char {`
`208`	`208`	`}`
`209`	`209`	`}`
`210`	`210`
`211`		`-impl DeserializeInner for char {`
	`211`	`+unsafe impl DeserializeInner for char {`
`212`	`212`	`#[inline(always)]`
`213`	`213`	`unsafe fn _deserialize_full_inner(backend: &mut impl ReadWithPos) -> deser::Result<Self> {`
`214`	`214`	`Ok(char::from_u32(u32::_deserialize_full_inner(backend)?).unwrap())`
`@@ -235,7 +235,7 @@ impl SerializeInner for () {`
`235`	`235`	`}`
`236`	`236`	`}`
`237`	`237`
`238`		`-impl DeserializeInner for () {`
	`238`	`+unsafe impl DeserializeInner for () {`
`239`	`239`	`#[inline(always)]`
`240`	`240`	`unsafe fn _deserialize_full_inner(_backend: &mut impl ReadWithPos) -> deser::Result<Self> {`
`241`	`241`	`Ok(())`
`@@ -288,7 +288,7 @@ impl<T: ?Sized> SerializeInner for PhantomData<T> {`
`288`	`288`	`}`
`289`	`289`	`}`
`290`	`290`
`291`		`-impl<T: ?Sized> DeserializeInner for PhantomData<T> {`
	`291`	`+unsafe impl<T: ?Sized> DeserializeInner for PhantomData<T> {`
`292`	`292`	`#[inline(always)]`
`293`	`293`	`unsafe fn _deserialize_full_inner(_backend: &mut impl ReadWithPos) -> deser::Result<Self> {`
`294`	`294`	`Ok(PhantomData::<T>)`
`@@ -339,7 +339,7 @@ impl<T: SerializeInner + TypeHash + AlignHash> SerializeInner for Option<T> {`
`339`	`339`	`}`
`340`	`340`	`}`
`341`	`341`
`342`		`-impl<T: DeserializeInner> DeserializeInner for Option<T> {`
	`342`	`+unsafe impl<T: DeserializeInner> DeserializeInner for Option<T> {`
`343`	`343`	`#[inline(always)]`
`344`	`344`	`unsafe fn _deserialize_full_inner(backend: &mut impl ReadWithPos) -> deser::Result<Self> {`
`345`	`345`	`let tag = u8::_deserialize_full_inner(backend)?;`
Original file line number	Diff line number	Diff line change
`@@ -94,7 +94,7 @@ impl<Idx: ZeroCopy + SerializeInner + TypeHash + AlignHash> SerializeInner`
`94`	`94`	`}`
`95`	`95`	`}`
`96`	`96`
`97`		`-impl<Idx: ZeroCopy + DeserializeInner> DeserializeInner for core::ops::Range<Idx> {`
	`97`	`+unsafe impl<Idx: ZeroCopy + DeserializeInner> DeserializeInner for core::ops::Range<Idx> {`
`98`	`98`	`#[inline(always)]`
`99`	`99`	`unsafe fn _deserialize_full_inner(backend: &mut impl ReadWithPos) -> deser::Result<Self> {`
`100`	`100`	`let start = Idx::_deserialize_full_inner(backend)?;`
`@@ -126,7 +126,7 @@ impl<Idx: ZeroCopy + SerializeInner + TypeHash + AlignHash> SerializeInner`
`126`	`126`	`}`
`127`	`127`	`}`
`128`	`128`
`129`		`-impl<Idx: ZeroCopy + DeserializeInner> DeserializeInner for core::ops::RangeFrom<Idx> {`
	`129`	`+unsafe impl<Idx: ZeroCopy + DeserializeInner> DeserializeInner for core::ops::RangeFrom<Idx> {`
`130`	`130`	`#[inline(always)]`
`131`	`131`	`unsafe fn _deserialize_full_inner(backend: &mut impl ReadWithPos) -> deser::Result<Self> {`
`132`	`132`	`let start = Idx::_deserialize_full_inner(backend)?;`
`@@ -158,7 +158,7 @@ impl<Idx: ZeroCopy + SerializeInner + TypeHash + AlignHash> SerializeInner`
`158`	`158`	`}`
`159`	`159`	`}`
`160`	`160`
`161`		`-impl<Idx: ZeroCopy + DeserializeInner> DeserializeInner for core::ops::RangeInclusive<Idx> {`
	`161`	`+unsafe impl<Idx: ZeroCopy + DeserializeInner> DeserializeInner for core::ops::RangeInclusive<Idx> {`
`162`	`162`	`#[inline(always)]`
`163`	`163`	`unsafe fn _deserialize_full_inner(backend: &mut impl ReadWithPos) -> deser::Result<Self> {`
`164`	`164`	`let start = Idx::_deserialize_full_inner(backend)?;`
`@@ -194,7 +194,7 @@ impl<Idx: ZeroCopy + SerializeInner + TypeHash + AlignHash> SerializeInner`
`194`	`194`	`}`
`195`	`195`	`}`
`196`	`196`
`197`		`-impl<Idx: ZeroCopy + DeserializeInner> DeserializeInner for core::ops::RangeTo<Idx> {`
	`197`	`+unsafe impl<Idx: ZeroCopy + DeserializeInner> DeserializeInner for core::ops::RangeTo<Idx> {`
`198`	`198`	`#[inline(always)]`
`199`	`199`	`unsafe fn _deserialize_full_inner(backend: &mut impl ReadWithPos) -> deser::Result<Self> {`
`200`	`200`	`let end = Idx::_deserialize_full_inner(backend)?;`
`@@ -224,7 +224,7 @@ impl<Idx: ZeroCopy + SerializeInner + TypeHash + AlignHash> SerializeInner`
`224`	`224`	`}`
`225`	`225`	`}`
`226`	`226`
`227`		`-impl<Idx: ZeroCopy + DeserializeInner> DeserializeInner for core::ops::RangeToInclusive<Idx> {`
	`227`	`+unsafe impl<Idx: ZeroCopy + DeserializeInner> DeserializeInner for core::ops::RangeToInclusive<Idx> {`
`228`	`228`	`#[inline(always)]`
`229`	`229`	`unsafe fn _deserialize_full_inner(backend: &mut impl ReadWithPos) -> deser::Result<Self> {`
`230`	`230`	`let end = Idx::_deserialize_full_inner(backend)?;`
`@@ -251,7 +251,7 @@ impl SerializeInner for core::ops::RangeFull {`
`251`	`251`	`}`
`252`	`252`	`}`
`253`	`253`
`254`		`-impl DeserializeInner for core::ops::RangeFull {`
	`254`	`+unsafe impl DeserializeInner for core::ops::RangeFull {`
`255`	`255`	`#[inline(always)]`
`256`	`256`	`unsafe fn _deserialize_full_inner(_backend: &mut impl ReadWithPos) -> deser::Result<Self> {`
`257`	`257`	`Ok(core::ops::RangeFull)`
`@@ -301,7 +301,7 @@ impl<T: SerializeInner + TypeHash + AlignHash> SerializeInner for core::ops::Bou`
`301`	`301`	`}`
`302`	`302`	`}`
`303`	`303`
`304`		`-impl<T: DeserializeInner> DeserializeInner for core::ops::Bound<T> {`
	`304`	`+unsafe impl<T: DeserializeInner> DeserializeInner for core::ops::Bound<T> {`
`305`	`305`	`#[inline(always)]`
`306`	`306`	`unsafe fn _deserialize_full_inner(backend: &mut impl ReadWithPos) -> deser::Result<Self> {`
`307`	`307`	`let tag = u8::_deserialize_full_inner(backend)?;`
`@@ -376,7 +376,7 @@ impl<B: SerializeInner + TypeHash + AlignHash, C: SerializeInner + TypeHash + Al`
`376`	`376`	`}`
`377`	`377`	`}`
`378`	`378`
`379`		`-impl<B: DeserializeInner, C: DeserializeInner> DeserializeInner for core::ops::ControlFlow<B, C> {`
	`379`	`+unsafe impl<B: DeserializeInner, C: DeserializeInner> DeserializeInner for core::ops::ControlFlow<B, C> {`
`380`	`380`	`#[inline(always)]`
`381`	`381`	`unsafe fn _deserialize_full_inner(backend: &mut impl ReadWithPos) -> deser::Result<Self> {`
`382`	`382`	`let tag = u8::_deserialize_full_inner(backend)?;`
Original file line number	Diff line number	Diff line change
`@@ -65,7 +65,7 @@ impl SerializeInner for String {`
`65`	`65`	`}`
`66`	`66`	`}`
`67`	`67`
`68`		`-impl DeserializeInner for String {`
	`68`	`+unsafe impl DeserializeInner for String {`
`69`	`69`	`unsafe fn _deserialize_full_inner(backend: &mut impl ReadWithPos) -> deser::Result<Self> {`
`70`	`70`	`let slice = deserialize_full_vec_zero(backend)?;`
`71`	`71`	`Ok(String::from_utf8(slice).unwrap())`
`@@ -99,7 +99,7 @@ impl SerializeInner for Box<str> {`
`99`	`99`	`}`
`100`	`100`	`}`
`101`	`101`
`102`		`-impl DeserializeInner for Box<str> {`
	`102`	`+unsafe impl DeserializeInner for Box<str> {`
`103`	`103`	`#[inline(always)]`
`104`	`104`	`unsafe fn _deserialize_full_inner(backend: &mut impl ReadWithPos) -> deser::Result<Self> {`
`105`	`105`	`Ok(String::_deserialize_full_inner(backend)?.into_boxed_str())`
Original file line number	Diff line number	Diff line change
`@@ -87,7 +87,7 @@ macro_rules! impl_tuples {`
`87`	`87`	`}`
`88`	`88`	`}`
`89`	`89`
`90`		`- impl<T: ZeroCopy + TypeHash + AlignHash> DeserializeInner for ($($t,)*) {`
	`90`	`+ unsafe impl<T: ZeroCopy + TypeHash + AlignHash> DeserializeInner for ($($t,)*) {`
`91`	`91`	`type DeserType<'a> = &'a ($($t,)*);`
`92`	`92`	`unsafe fn _deserialize_full_inner(backend: &mut impl ReadWithPos) -> deser::Result<Self> {`
`93`	`93`	`deserialize_full_zero::<($($t,)*)>(backend)`
Original file line number	Diff line number	Diff line change
`@@ -66,7 +66,7 @@ impl<T: DeepCopy + SerializeInner> SerializeHelper<Deep> for Vec<T> {`
`66`	`66`	`}`
`67`	`67`
`68`	`68`	`// This delegates to a private helper trait which we can specialize on in stable rust`
`69`		`-impl<T: CopyType + DeserializeInner> DeserializeInner for Vec<T>`
	`69`	`+unsafe impl<T: CopyType + DeserializeInner> DeserializeInner for Vec<T>`
`70`	`70`	`where`
`71`	`71`	`Vec<T>: DeserializeHelper<<T as CopyType>::Copy, FullType = Vec<T>>,`
`72`	`72`	`{`