tls_codec: Rename functions in DeserializeBytes trait (#1251)

* rename functions in DeserializeBytes trait, using _bytes postfix
* remove unnecessary qualifications
* remove deserialize_bytes from Deserialize trait
* add Changelog

tls_codec/CHANGELOG.md

@@ -0,0 +1,16 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Changed
+
+- [#1251](https://github.com/RustCrypto/formats/pull/1251): Add `_bytes` suffix to function names in the `DeserializeBytes` trait to avoid collisions with function names in the `Deserialize` trait
+
+### Removed
+
+- [#1251](https://github.com/RustCrypto/formats/pull/1251): Remove the `tls_deserialize_bytes` function from the `Deserialize` trait

tls_codec/benches/quic_vec.rs

@@ -20,8 +20,7 @@ fn vector(c: &mut Criterion) {
             },
             |serialized_long_vec| {
                 let _deserialized_long_vec =
-                    <Vec<u8> as Deserialize>::tls_deserialize(&mut serialized_long_vec.as_slice())
-                        .unwrap();
+                    Vec::<u8>::tls_deserialize(&mut serialized_long_vec.as_slice()).unwrap();
             },
             BatchSize::SmallInput,
         )
@@ -47,8 +46,7 @@ fn byte_vector(c: &mut Criterion) {
             },
             |serialized_long_vec| {
                 let _deserialized_long_vec =
-                    <VLBytes as Deserialize>::tls_deserialize(&mut serialized_long_vec.as_slice())
-                        .unwrap();
+                    VLBytes::tls_deserialize(&mut serialized_long_vec.as_slice()).unwrap();
             },
             BatchSize::SmallInput,
         )

tls_codec/benches/tls_vec.rs

@@ -19,10 +19,8 @@ fn vector(c: &mut Criterion) {
                 TlsSliceU32(&long_vector).tls_serialize_detached().unwrap()
             },
             |serialized_long_vec| {
-                let _deserialized_long_vec = <TlsVecU32<u8> as Deserialize>::tls_deserialize(
-                    &mut serialized_long_vec.as_slice(),
-                )
-                .unwrap();
+                let _deserialized_long_vec =
+                    TlsVecU32::<u8>::tls_deserialize(&mut serialized_long_vec.as_slice()).unwrap();
             },
             BatchSize::SmallInput,
         )
@@ -49,10 +47,8 @@ fn byte_vector(c: &mut Criterion) {
                     .unwrap()
             },
             |serialized_long_vec| {
-                let _deserialized_long_vec = <TlsVecU32<u8> as Deserialize>::tls_deserialize(
-                    &mut serialized_long_vec.as_slice(),
-                )
-                .unwrap();
+                let _deserialized_long_vec =
+                    TlsVecU32::<u8>::tls_deserialize(&mut serialized_long_vec.as_slice()).unwrap();
             },
             BatchSize::SmallInput,
         )

tls_codec/derive/src/lib.rs

@@ -1005,8 +1005,8 @@ fn impl_deserialize_bytes(parsed_ast: TlsStruct) -> TokenStream2 {
             let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
             quote! {
                 impl #impl_generics tls_codec::DeserializeBytes for #ident #ty_generics #where_clause {
-                    fn tls_deserialize(bytes: &[u8]) -> core::result::Result<(Self, &[u8]), tls_codec::Error> {
-                        #(let (#members_values, bytes) = #prefixes::tls_deserialize(bytes)?;)*
+                    fn tls_deserialize_bytes(bytes: &[u8]) -> core::result::Result<(Self, &[u8]), tls_codec::Error> {
+                        #(let (#members_values, bytes) = #prefixes::tls_deserialize_bytes(bytes)?;)*
                         Ok((Self {
                             #(#members: #members_values,)*
                             #(#members_default: Default::default(),)*
@@ -1049,7 +1049,7 @@ fn impl_deserialize_bytes(parsed_ast: TlsStruct) -> TokenStream2 {
                         .collect::<Vec<_>>();
                     quote! {
                         #discriminant => {
-                            #(let (#member_values, remainder) = #prefixes::tls_deserialize(remainder)?;)*
+                            #(let (#member_values, remainder) = #prefixes::tls_deserialize_bytes(remainder)?;)*
                             let result = #ident::#variant_id { #(#members: #member_values,)* };
                             Ok((result, remainder))
                         },
@@ -1059,9 +1059,9 @@ fn impl_deserialize_bytes(parsed_ast: TlsStruct) -> TokenStream2 {
             let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
             quote! {
                 impl #impl_generics tls_codec::DeserializeBytes for #ident #ty_generics #where_clause {
-                    fn tls_deserialize(bytes: &[u8]) -> core::result::Result<(Self, &[u8]), tls_codec::Error> {
+                    fn tls_deserialize_bytes(bytes: &[u8]) -> core::result::Result<(Self, &[u8]), tls_codec::Error> {
                         #discriminant_constants
-                        let (discriminant, remainder) = <#repr as tls_codec::DeserializeBytes>::tls_deserialize(bytes)?;
+                        let (discriminant, remainder) = #repr::tls_deserialize_bytes(bytes)?;
                         match discriminant {
                             #(#arms)*
                             _ => {

tls_codec/derive/tests/decode.rs

@@ -1,6 +1,7 @@
 #![cfg(feature = "std")]
 use tls_codec::{
-    Deserialize, Error, Serialize, Size, TlsSliceU16, TlsVecU16, TlsVecU32, TlsVecU8, VLBytes,
+    Deserialize, DeserializeBytes, Error, Serialize, Size, TlsSliceU16, TlsVecU16, TlsVecU32,
+    TlsVecU8, VLBytes,
 };
 use tls_codec_derive::{TlsDeserialize, TlsDeserializeBytes, TlsSerialize, TlsSize};
 
@@ -58,8 +59,7 @@ fn tuple_struct() {
     let serialized_t1 = t1.tls_serialize_detached().unwrap();
     let deserialized_t1 = TupleStruct1::tls_deserialize(&mut serialized_t1.as_slice()).unwrap();
     let (deserialized_bytes_t1, _remainder) =
-        <TupleStruct1 as tls_codec::DeserializeBytes>::tls_deserialize(serialized_t1.as_slice())
-            .unwrap();
+        TupleStruct1::tls_deserialize_bytes(serialized_t1.as_slice()).unwrap();
     assert_eq!(t1, deserialized_t1);
     assert_eq!(t1, deserialized_bytes_t1);
     assert_eq!(
@@ -75,8 +75,7 @@ fn tuple_struct() {
     let serialized_t2 = t2.tls_serialize_detached().unwrap();
     let deserialized_t2 = TupleStruct::tls_deserialize(&mut serialized_t2.as_slice()).unwrap();
     let (deserialized_bytes_t2, _remainder) =
-        <TupleStruct as tls_codec::DeserializeBytes>::tls_deserialize(serialized_t2.as_slice())
-            .unwrap();
+        TupleStruct::tls_deserialize_bytes(serialized_t2.as_slice()).unwrap();
     assert_eq!(t2, deserialized_t2);
     assert_eq!(t2, deserialized_bytes_t2);
     assert_eq!(
@@ -94,8 +93,7 @@ fn simple_enum() {
     let b = &[0u8, 5] as &[u8];
     let mut b_reader = b;
     let deserialized = ExtensionType::tls_deserialize(&mut b_reader).unwrap();
-    let (deserialized_bytes, _remainder) =
-        <ExtensionType as tls_codec::DeserializeBytes>::tls_deserialize(b).unwrap();
+    let (deserialized_bytes, _remainder) = ExtensionType::tls_deserialize_bytes(b).unwrap();
     assert_eq!(ExtensionType::RatchetTree, deserialized);
     assert_eq!(ExtensionType::RatchetTree, deserialized_bytes);
 
@@ -109,8 +107,7 @@ fn simple_enum() {
     for variant in variants.iter() {
         let deserialized = ExtensionType::tls_deserialize(&mut b_reader).unwrap();
         assert_eq!(variant, &deserialized);
-        let (deserialized_bytes, remainder) =
-            <ExtensionType as tls_codec::DeserializeBytes>::tls_deserialize(b).unwrap();
+        let (deserialized_bytes, remainder) = ExtensionType::tls_deserialize_bytes(b).unwrap();
         b = remainder;
         assert_eq!(variant, &deserialized_bytes);
     }
@@ -129,11 +126,9 @@ fn deserialize_tls_vec() {
     assert_eq!(long_vector.len(), deserialized_long_vec.len());
     assert_eq!(long_vector, deserialized_long_vec);
     let (deserialized_long_vec_bytes, _remainder): (Vec<ExtensionStruct>, &[u8]) =
-        <TlsVecU16<ExtensionStruct> as tls_codec::DeserializeBytes>::tls_deserialize(
-            serialized_long_vec.as_slice(),
-        )
-        .map(|(v, r)| (v.into(), r))
-        .unwrap();
+        TlsVecU16::<ExtensionStruct>::tls_deserialize_bytes(serialized_long_vec.as_slice())
+            .map(|(v, r)| (v.into(), r))
+            .unwrap();
     assert_eq!(long_vector.len(), deserialized_long_vec_bytes.len());
     assert_eq!(long_vector, deserialized_long_vec_bytes);
 }
@@ -304,8 +299,8 @@ mod custom_bytes {
         TlsByteSliceU32(v).tls_serialize(writer)
     }
 
-    pub fn tls_deserialize(bytes: &[u8]) -> Result<(Vec<u8>, &[u8]), tls_codec::Error> {
-        let (vec, remainder) = TlsByteVecU32::tls_deserialize(bytes)?;
+    pub fn tls_deserialize_bytes(bytes: &[u8]) -> Result<(Vec<u8>, &[u8]), tls_codec::Error> {
+        let (vec, remainder) = TlsByteVecU32::tls_deserialize_bytes(bytes)?;
         Ok((vec.into_vec(), remainder))
     }
 }

tls_codec/derive/tests/decode_bytes.rs

@@ -31,15 +31,13 @@ struct SomeValue {
 #[test]
 fn simple_enum() {
     let serialized = ExtensionType::KeyId.tls_serialize().unwrap();
-    let (deserialized, rest) =
-        <ExtensionType as DeserializeBytes>::tls_deserialize(&serialized).unwrap();
+    let (deserialized, rest) = ExtensionType::tls_deserialize_bytes(&serialized).unwrap();
     assert_eq!(deserialized, ExtensionType::KeyId);
-    assert_eq!(rest, []);
+    assert!(rest.is_empty());
     let serialized = ExtensionType::SomethingElse.tls_serialize().unwrap();
-    let (deserialized, rest) =
-        <ExtensionType as DeserializeBytes>::tls_deserialize(&serialized).unwrap();
+    let (deserialized, rest) = ExtensionType::tls_deserialize_bytes(&serialized).unwrap();
     assert_eq!(deserialized, ExtensionType::SomethingElse);
-    assert_eq!(rest, []);
+    assert!(rest.is_empty());
 }
 
 #[test]
@@ -50,10 +48,9 @@ fn simple_struct() {
         additional_data: None,
     };
     let serialized = extension.tls_serialize().unwrap();
-    let (deserialized, rest) =
-        <ExtensionStruct as DeserializeBytes>::tls_deserialize(&serialized).unwrap();
+    let (deserialized, rest) = ExtensionStruct::tls_deserialize_bytes(&serialized).unwrap();
     assert_eq!(deserialized, extension);
-    assert_eq!(rest, []);
+    assert!(rest.is_empty());
 }
 
 #[test]
@@ -65,19 +62,18 @@ fn tuple_struct() {
     };
     let x = TupleStruct(ext, 6);
     let serialized = x.tls_serialize().unwrap();
-    let (deserialized, rest) =
-        <TupleStruct as DeserializeBytes>::tls_deserialize(&serialized).unwrap();
+    let (deserialized, rest) = TupleStruct::tls_deserialize_bytes(&serialized).unwrap();
     assert_eq!(deserialized, x);
-    assert_eq!(rest, []);
+    assert!(rest.is_empty());
 }
 
 #[test]
 fn byte_arrays() {
     let x = [0u8, 1, 2, 3];
     let serialized = x.tls_serialize().unwrap();
-    let (deserialized, rest) = <[u8; 4] as DeserializeBytes>::tls_deserialize(&serialized).unwrap();
+    let (deserialized, rest) = <[u8; 4]>::tls_deserialize_bytes(&serialized).unwrap();
     assert_eq!(deserialized, x);
-    assert_eq!(rest, []);
+    assert!(rest.is_empty());
 }
 
 #[derive(TlsSerializeBytes, TlsDeserializeBytes, TlsSize, Debug, PartialEq)]
@@ -98,10 +94,10 @@ mod custom {
         v.tls_serialize()
     }
 
-    pub fn tls_deserialize<T: DeserializeBytes>(
+    pub fn tls_deserialize_bytes<T: DeserializeBytes>(
         bytes: &[u8],
     ) -> Result<(T, &[u8]), tls_codec::Error> {
-        <T as DeserializeBytes>::tls_deserialize(bytes)
+        T::tls_deserialize_bytes(bytes)
     }
 }
 
@@ -113,9 +109,9 @@ fn custom() {
     };
     let serialized = x.tls_serialize().unwrap();
     assert_eq!(vec![3, 0, 1, 2, 3], serialized);
-    let (deserialized, rest) = <Custom as DeserializeBytes>::tls_deserialize(&serialized).unwrap();
+    let (deserialized, rest) = Custom::tls_deserialize_bytes(&serialized).unwrap();
     assert_eq!(deserialized, x);
-    assert_eq!(rest, []);
+    assert!(rest.is_empty());
 }
 
 #[derive(TlsSerializeBytes, TlsDeserializeBytes, TlsSize, Debug, PartialEq)]
@@ -128,10 +124,9 @@ enum EnumWithTupleVariant {
 fn enum_with_tuple_variant() {
     let x = EnumWithTupleVariant::A(3, 4);
     let serialized = x.tls_serialize().unwrap();
-    let (deserialized, rest) =
-        <EnumWithTupleVariant as DeserializeBytes>::tls_deserialize(&serialized).unwrap();
+    let (deserialized, rest) = EnumWithTupleVariant::tls_deserialize_bytes(&serialized).unwrap();
     assert_eq!(deserialized, x);
-    assert_eq!(rest, []);
+    assert!(rest.is_empty());
 }
 
 #[derive(TlsSerializeBytes, TlsDeserializeBytes, TlsSize, Debug, PartialEq)]
@@ -144,10 +139,9 @@ enum EnumWithStructVariant {
 fn enum_with_struct_variant() {
     let x = EnumWithStructVariant::A { foo: 3, bar: 4 };
     let serialized = x.tls_serialize().unwrap();
-    let (deserialized, rest) =
-        <EnumWithStructVariant as DeserializeBytes>::tls_deserialize(&serialized).unwrap();
+    let (deserialized, rest) = EnumWithStructVariant::tls_deserialize_bytes(&serialized).unwrap();
     assert_eq!(deserialized, x);
-    assert_eq!(rest, []);
+    assert!(rest.is_empty());
 }
 
 #[derive(TlsSerializeBytes, TlsDeserializeBytes, TlsSize, Debug, PartialEq)]
@@ -164,19 +158,19 @@ fn enum_with_data_and_discriminant() {
     let serialized = x.tls_serialize().unwrap();
 
     let (deserialized, rest) =
-        <EnumWithDataAndDiscriminant as DeserializeBytes>::tls_deserialize(&serialized).unwrap();
+        EnumWithDataAndDiscriminant::tls_deserialize_bytes(&serialized).unwrap();
     assert_eq!(deserialized, x);
-    assert_eq!(rest, []);
+    assert!(rest.is_empty());
 }
 
 #[test]
 fn discriminant_is_incremented_implicitly() {
     let x = EnumWithDataAndDiscriminant::B;
     let serialized = x.tls_serialize().unwrap();
     let (deserialized, rest) =
-        <EnumWithDataAndDiscriminant as DeserializeBytes>::tls_deserialize(&serialized).unwrap();
+        EnumWithDataAndDiscriminant::tls_deserialize_bytes(&serialized).unwrap();
     assert_eq!(deserialized, x);
-    assert_eq!(rest, []);
+    assert!(rest.is_empty());
 }
 
 mod discriminant {
@@ -209,26 +203,23 @@ fn enum_with_data_and_const_discriminant() {
     let serialized = x.tls_serialize().unwrap();
     assert_eq!(vec![0, 3, 4], serialized);
     let (deserialized, rest) =
-        <EnumWithDataAndConstDiscriminant as DeserializeBytes>::tls_deserialize(&serialized)
-            .unwrap();
+        EnumWithDataAndConstDiscriminant::tls_deserialize_bytes(&serialized).unwrap();
     assert_eq!(deserialized, x);
-    assert_eq!(rest, []);
+    assert!(rest.is_empty());
 
     let x = EnumWithDataAndConstDiscriminant::B;
     let serialized = x.tls_serialize().unwrap();
     let (deserialized, rest) =
-        <EnumWithDataAndConstDiscriminant as DeserializeBytes>::tls_deserialize(&serialized)
-            .unwrap();
+        EnumWithDataAndConstDiscriminant::tls_deserialize_bytes(&serialized).unwrap();
     assert_eq!(deserialized, x);
-    assert_eq!(rest, []);
+    assert!(rest.is_empty());
 
     let x = EnumWithDataAndConstDiscriminant::C;
     let serialized = x.tls_serialize().unwrap();
     let (deserialized, rest) =
-        <EnumWithDataAndConstDiscriminant as DeserializeBytes>::tls_deserialize(&serialized)
-            .unwrap();
+        EnumWithDataAndConstDiscriminant::tls_deserialize_bytes(&serialized).unwrap();
     assert_eq!(deserialized, x);
-    assert_eq!(rest, []);
+    assert!(rest.is_empty());
 }
 
 #[derive(TlsSerializeBytes, TlsDeserializeBytes, TlsSize, Debug, PartialEq)]
@@ -242,9 +233,9 @@ fn enum_with_custom_serialized_field() {
     let x = EnumWithCustomSerializedField::A(vec![1, 2, 3]);
     let serialized = x.tls_serialize().unwrap();
     let (deserialized, rest) =
-        <EnumWithCustomSerializedField as DeserializeBytes>::tls_deserialize(&serialized).unwrap();
+        EnumWithCustomSerializedField::tls_deserialize_bytes(&serialized).unwrap();
     assert_eq!(deserialized, x);
-    assert_eq!(rest, []);
+    assert!(rest.is_empty());
 }
 
 #[test]
@@ -254,9 +245,9 @@ fn that_skip_attribute_on_struct_works() {
         T: std::fmt::Debug + PartialEq + SerializeBytes + Size,
     {
         let serialized = test.tls_serialize().unwrap();
-        let (deserialized, rest) = <T as DeserializeBytes>::tls_deserialize(&serialized).unwrap();
+        let (deserialized, rest) = T::tls_deserialize_bytes(&serialized).unwrap();
         assert_eq!(deserialized, expected);
-        assert_eq!(rest, []);
+        assert!(rest.is_empty());
     }
 
     #[derive(Debug, PartialEq, TlsSerializeBytes, TlsDeserializeBytes, TlsSize)]

tls_codec/src/arrays.rs

@@ -34,7 +34,7 @@ impl<const LEN: usize> Deserialize for [u8; LEN] {
 
 impl<const LEN: usize> DeserializeBytes for [u8; LEN] {
     #[inline]
-    fn tls_deserialize(bytes: &[u8]) -> Result<(Self, &[u8]), Error> {
+    fn tls_deserialize_bytes(bytes: &[u8]) -> Result<(Self, &[u8]), Error> {
         let out = bytes
             .get(..LEN)
             .ok_or(Error::EndOfStream)?