tls_codec: bump to 0.5 and change SerializeBytes

tls_codec/CHANGELOG.md

@@ -7,10 +7,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-## 0.4.3
+## 0.5.0
 
+- BREAKING: Rename `SerializeBytes::tls_serialize` to `SerializeBytes::tls_serialize_bytes` to resolve a method-name collision with `Serialize::tls_serialize` (this matches the existing `DeserializeBytes::tls_deserialize_bytes` convention). Any type using `#[tls_codec(with = "...")]` together with `TlsSerializeBytes` must rename its module's `tls_serialize` function to `tls_serialize_bytes` accordingly.
 - [#2351](https://github.com/RustCrypto/formats/pull/2351): Implement `Size`, `SerializeBytes`, and `DeserializeBytes` for `String` (and `Size`/`SerializeBytes` for `str` / `&str`), encoding the UTF-8 bytes as a `VLByteVec`. Also implement `SerializeBytes` for `ContentLength` and `VLByteSlice`.
-- [#2322](https://github.com/RustCrypto/formats/pull/2322): Add `VLByteVec` and `SecretVLByteVec`, which are `#[serde(transparent)]` wrappers serializing via `serde_bytes`. They produce a much more compact representation in `serde` formats that distinguish byte arrays from sequences of `u8` (e.g. CBOR, MessagePack, bincode). Their `serde` output is not compatible with `VLBytes` / `SecretVLBytes`, but their `Deserialize` impls are backwards-compatible: in self-describing `serde` formats they also accept the legacy `VLBytes` / `SecretVLBytes` encoding (a struct with a `vec` field containing a sequence of `u8`). Deprecate `VLBytes` and `SecretVLBytes` in favour of `VLByteVec` and `SecretVLByteVec`.
+- [#2322](https://github.com/RustCrypto/formats/pull/2322): Add `VLByteVec` and `SecretVLByteVec`, which are `#[serde(transparent)]` wrappers serializing via `serde_bytes`. They produce a much more compact representation in `serde` formats that distinguish byte arrays from sequences of `u8` (e.g. CBOR, MessagePack, bincode). Their `serde` output is not compatible with `VLBytes` / `SecretVLBytes`, but their `Deserialize` impls are backwards-compatible: in self-describing `serde` formats they also accept the legacy `VLBytes` / `SecretVLBytes` encoding (a struct with a `vec` field containing a sequence of `u8`). `VLBytes` and `SecretVLBytes` will be deprecated in future in favour of `VLByteVec` and `SecretVLByteVec`.
 - [#1656](https://github.com/RustCrypto/formats/pull/1656) Add `TlsVarInt` type for variable-length integers.
 
 ### Changed

tls_codec/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tls_codec"
-version = "0.4.3-pre.1"
+version = "0.5.0-pre.1"
 authors = ["RustCrypto Developers"]
 license = "Apache-2.0 OR MIT"
 documentation = "https://docs.rs/tls_codec/"
@@ -16,7 +16,7 @@ zeroize = { version = "1.9", default-features = false, features = ["alloc"] }
 
 # optional dependencies
 arbitrary = { version = "1.4", features = ["derive"], optional = true }
-tls_codec_derive = { version = "=0.4.3-pre.1", path = "./derive", optional = true }
+tls_codec_derive = { version = "=0.5.0-pre.1", path = "./derive", optional = true }
 serde = { version = "1.0.228", features = ["derive"], optional = true }
 serde_bytes = { version = "0.11.19", optional = true }
 
@@ -36,6 +36,7 @@ conditional_deserialization = [
     "derive",
     "tls_codec_derive/conditional_deserialization",
 ]
+future_deprecations = []
 
 [[bench]]
 name = "tls_vec"

tls_codec/benches/quic_vec.rs

@@ -1,5 +1,4 @@
-// The benches intentionally exercise the deprecated `VLBytes`.
-#![allow(deprecated)]
+#![cfg_attr(feature = "future_deprecations", allow(deprecated))]
 
 use criterion::{BatchSize, Criterion};
 use criterion::{criterion_group, criterion_main};

tls_codec/derive/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tls_codec_derive"
-version = "0.4.3-pre.1"
+version = "0.5.0-pre.1"
 authors = ["RustCrypto Developers"]
 license = "Apache-2.0 OR MIT"
 documentation = "https://docs.rs/tls_codec_derive/"
@@ -27,3 +27,9 @@ trybuild = "1"
 default = ["std"]
 conditional_deserialization = ["syn/full"]
 std = []
+# Declared only so the derive tests can gate their `allow(deprecated)` on
+# `#[cfg_attr(feature = "future_deprecations", ...)]` without tripping the
+# `unexpected_cfgs` lint. It intentionally does not forward to `tls_codec`
+# (which is only a dev-dependency here, so it cannot be forwarded to under
+# `cargo hack --no-dev-deps`).
+future_deprecations = []

tls_codec/derive/src/lib.rs

@@ -975,7 +975,7 @@ fn impl_serialize(parsed_ast: TlsStruct, svariant: SerializeVariant) -> TokenStr
                 SerializeVariant::Bytes => {
                     quote! {
                         impl #impl_generics tls_codec::SerializeBytes for #ident #ty_generics #where_clause {
-                            fn tls_serialize(&self) -> core::result::Result<Vec<u8>, tls_codec::Error> {
+                            fn tls_serialize_bytes(&self) -> core::result::Result<Vec<u8>, tls_codec::Error> {
                                 let expected_out = tls_codec::Size::tls_serialized_len(&self);
                                 // On narrow targets `expected_out` saturates when the serialized
                                 // form exceeds `usize::MAX`; reject it before it reaches
@@ -987,7 +987,7 @@ fn impl_serialize(parsed_ast: TlsStruct, svariant: SerializeVariant) -> TokenStr
                                 let mut out = Vec::with_capacity(expected_out);
 
                                 #(
-                                    out.append(&mut #prefixes::tls_serialize(&self.#members)?);
+                                    out.append(&mut #prefixes::tls_serialize_bytes(&self.#members)?);
                                 )*
                                 if cfg!(debug_assertions) {
                                     debug_assert_eq!(out.len(), expected_out, "Expected to serialize {} bytes but only {} were generated.", expected_out, out.len());
@@ -1003,8 +1003,8 @@ fn impl_serialize(parsed_ast: TlsStruct, svariant: SerializeVariant) -> TokenStr
                         }
 
                         impl #impl_generics tls_codec::SerializeBytes for &#ident #ty_generics #where_clause {
-                            fn tls_serialize(&self) -> core::result::Result<Vec<u8>, tls_codec::Error> {
-                                tls_codec::SerializeBytes::tls_serialize(*self)
+                            fn tls_serialize_bytes(&self) -> core::result::Result<Vec<u8>, tls_codec::Error> {
+                                tls_codec::SerializeBytes::tls_serialize_bytes(*self)
                             }
                         }
                     }
@@ -1048,8 +1048,8 @@ fn impl_serialize(parsed_ast: TlsStruct, svariant: SerializeVariant) -> TokenStr
                                 .collect::<Vec<_>>();
                             quote! {
                                 #ident::#variant_id { #(#members: #bindings,)* } => {
-                                    let mut discriminant_out = tls_codec::SerializeBytes::tls_serialize(&#discriminant)?;
-                                    #(discriminant_out.append(&mut #prefixes::tls_serialize(#bindings)?);)*
+                                    let mut discriminant_out = tls_codec::SerializeBytes::tls_serialize_bytes(&#discriminant)?;
+                                    #(discriminant_out.append(&mut #prefixes::tls_serialize_bytes(#bindings)?);)*
                                     Ok(discriminant_out)
                                 },
                             }
@@ -1090,7 +1090,7 @@ fn impl_serialize(parsed_ast: TlsStruct, svariant: SerializeVariant) -> TokenStr
                 SerializeVariant::Bytes => {
                     quote! {
                         impl #impl_generics tls_codec::SerializeBytes for #ident #ty_generics #where_clause {
-                            fn tls_serialize(&self) -> core::result::Result<Vec<u8>, tls_codec::Error> {
+                            fn tls_serialize_bytes(&self) -> core::result::Result<Vec<u8>, tls_codec::Error> {
                                 #discriminant_constants
                                 match self {
                                     #(#arms)*
@@ -1099,8 +1099,8 @@ fn impl_serialize(parsed_ast: TlsStruct, svariant: SerializeVariant) -> TokenStr
                         }
 
                         impl #impl_generics tls_codec::SerializeBytes for &#ident #ty_generics #where_clause {
-                            fn tls_serialize(&self) -> core::result::Result<Vec<u8>, tls_codec::Error> {
-                                tls_codec::SerializeBytes::tls_serialize(*self)
+                            fn tls_serialize_bytes(&self) -> core::result::Result<Vec<u8>, tls_codec::Error> {
+                                tls_codec::SerializeBytes::tls_serialize_bytes(*self)
                             }
                         }
                     }

tls_codec/derive/tests/decode.rs

@@ -1,7 +1,5 @@
 #![cfg(feature = "std")]
-// These tests intentionally exercise the deprecated `VLBytes` for backward
-// compatibility coverage.
-#![allow(deprecated)]
+#![cfg_attr(feature = "future_deprecations", allow(deprecated))]
 use tls_codec::{
     Deserialize, DeserializeBytes, Error, Serialize, Size, TlsSliceU16, TlsVecU8, TlsVecU16,
     TlsVecU32, VLBytes,

tls_codec/derive/tests/decode_bytes.rs

@@ -30,11 +30,11 @@ struct SomeValue {
 
 #[test]
 fn simple_enum() {
-    let serialized = ExtensionType::KeyId.tls_serialize().unwrap();
+    let serialized = ExtensionType::KeyId.tls_serialize_bytes().unwrap();
     let (deserialized, rest) = ExtensionType::tls_deserialize_bytes(&serialized).unwrap();
     assert_eq!(deserialized, ExtensionType::KeyId);
     assert!(rest.is_empty());
-    let serialized = ExtensionType::SomethingElse.tls_serialize().unwrap();
+    let serialized = ExtensionType::SomethingElse.tls_serialize_bytes().unwrap();
     let (deserialized, rest) = ExtensionType::tls_deserialize_bytes(&serialized).unwrap();
     assert_eq!(deserialized, ExtensionType::SomethingElse);
     assert!(rest.is_empty());
@@ -47,7 +47,7 @@ fn simple_struct() {
         extension_data: vec![1, 2, 3, 4, 5],
         additional_data: None,
     };
-    let serialized = extension.tls_serialize().unwrap();
+    let serialized = extension.tls_serialize_bytes().unwrap();
     let (deserialized, rest) = ExtensionStruct::tls_deserialize_bytes(&serialized).unwrap();
     assert_eq!(deserialized, extension);
     assert!(rest.is_empty());
@@ -61,7 +61,7 @@ fn tuple_struct() {
         additional_data: None,
     };
     let x = TupleStruct(ext, 6);
-    let serialized = x.tls_serialize().unwrap();
+    let serialized = x.tls_serialize_bytes().unwrap();
     let (deserialized, rest) = TupleStruct::tls_deserialize_bytes(&serialized).unwrap();
     assert_eq!(deserialized, x);
     assert!(rest.is_empty());
@@ -70,7 +70,7 @@ fn tuple_struct() {
 #[test]
 fn byte_arrays() {
     let x = [0u8, 1, 2, 3];
-    let serialized = x.tls_serialize().unwrap();
+    let serialized = x.tls_serialize_bytes().unwrap();
     let (deserialized, rest) = <[u8; 4]>::tls_deserialize_bytes(&serialized).unwrap();
     assert_eq!(deserialized, x);
     assert!(rest.is_empty());
@@ -90,8 +90,8 @@ mod custom {
         v.tls_serialized_len()
     }
 
-    pub fn tls_serialize(v: &[u8]) -> Result<Vec<u8>, tls_codec::Error> {
-        v.tls_serialize()
+    pub fn tls_serialize_bytes(v: &[u8]) -> Result<Vec<u8>, tls_codec::Error> {
+        v.tls_serialize_bytes()
     }
 
     pub fn tls_deserialize_bytes<T: DeserializeBytes>(
@@ -107,7 +107,7 @@ fn custom() {
         values: vec![0, 1, 2],
         a: 3,
     };
-    let serialized = x.tls_serialize().unwrap();
+    let serialized = x.tls_serialize_bytes().unwrap();
     assert_eq!(vec![3, 0, 1, 2, 3], serialized);
     let (deserialized, rest) = Custom::tls_deserialize_bytes(&serialized).unwrap();
     assert_eq!(deserialized, x);
@@ -123,7 +123,7 @@ enum EnumWithTupleVariant {
 #[test]
 fn enum_with_tuple_variant() {
     let x = EnumWithTupleVariant::A(3, 4);
-    let serialized = x.tls_serialize().unwrap();
+    let serialized = x.tls_serialize_bytes().unwrap();
     let (deserialized, rest) = EnumWithTupleVariant::tls_deserialize_bytes(&serialized).unwrap();
     assert_eq!(deserialized, x);
     assert!(rest.is_empty());
@@ -138,7 +138,7 @@ enum EnumWithStructVariant {
 #[test]
 fn enum_with_struct_variant() {
     let x = EnumWithStructVariant::A { foo: 3, bar: 4 };
-    let serialized = x.tls_serialize().unwrap();
+    let serialized = x.tls_serialize_bytes().unwrap();
     let (deserialized, rest) = EnumWithStructVariant::tls_deserialize_bytes(&serialized).unwrap();
     assert_eq!(deserialized, x);
     assert!(rest.is_empty());
@@ -155,7 +155,7 @@ enum EnumWithDataAndDiscriminant {
 #[test]
 fn enum_with_data_and_discriminant() {
     let x = EnumWithDataAndDiscriminant::A(4);
-    let serialized = x.tls_serialize().unwrap();
+    let serialized = x.tls_serialize_bytes().unwrap();
 
     let (deserialized, rest) =
         EnumWithDataAndDiscriminant::tls_deserialize_bytes(&serialized).unwrap();
@@ -166,7 +166,7 @@ fn enum_with_data_and_discriminant() {
 #[test]
 fn discriminant_is_incremented_implicitly() {
     let x = EnumWithDataAndDiscriminant::B;
-    let serialized = x.tls_serialize().unwrap();
+    let serialized = x.tls_serialize_bytes().unwrap();
     let (deserialized, rest) =
         EnumWithDataAndDiscriminant::tls_deserialize_bytes(&serialized).unwrap();
     assert_eq!(deserialized, x);
@@ -200,22 +200,22 @@ enum EnumWithDataAndConstDiscriminant {
 #[test]
 fn enum_with_data_and_const_discriminant() {
     let x = EnumWithDataAndConstDiscriminant::A(4);
-    let serialized = x.tls_serialize().unwrap();
+    let serialized = x.tls_serialize_bytes().unwrap();
     assert_eq!(vec![0, 3, 4], serialized);
     let (deserialized, rest) =
         EnumWithDataAndConstDiscriminant::tls_deserialize_bytes(&serialized).unwrap();
     assert_eq!(deserialized, x);
     assert!(rest.is_empty());
 
     let x = EnumWithDataAndConstDiscriminant::B;
-    let serialized = x.tls_serialize().unwrap();
+    let serialized = x.tls_serialize_bytes().unwrap();
     let (deserialized, rest) =
         EnumWithDataAndConstDiscriminant::tls_deserialize_bytes(&serialized).unwrap();
     assert_eq!(deserialized, x);
     assert!(rest.is_empty());
 
     let x = EnumWithDataAndConstDiscriminant::C;
-    let serialized = x.tls_serialize().unwrap();
+    let serialized = x.tls_serialize_bytes().unwrap();
     let (deserialized, rest) =
         EnumWithDataAndConstDiscriminant::tls_deserialize_bytes(&serialized).unwrap();
     assert_eq!(deserialized, x);
@@ -231,7 +231,7 @@ enum EnumWithCustomSerializedField {
 #[test]
 fn enum_with_custom_serialized_field() {
     let x = EnumWithCustomSerializedField::A(vec![1, 2, 3]);
-    let serialized = x.tls_serialize().unwrap();
+    let serialized = x.tls_serialize_bytes().unwrap();
     let (deserialized, rest) =
         EnumWithCustomSerializedField::tls_deserialize_bytes(&serialized).unwrap();
     assert_eq!(deserialized, x);
@@ -244,7 +244,7 @@ fn that_skip_attribute_on_struct_works() {
     where
         T: DeserializeBytes + std::fmt::Debug + PartialEq + SerializeBytes + Size,
     {
-        let serialized = test.tls_serialize().unwrap();
+        let serialized = test.tls_serialize_bytes().unwrap();
         let (deserialized, rest) = T::tls_deserialize_bytes(&serialized).unwrap();
         assert_eq!(deserialized, expected);
         assert!(rest.is_empty());