From 4202d8073a7e544490348b84a0ab31cb38926ee2 Mon Sep 17 00:00:00 2001 From: Alex Coats Date: Wed, 7 Feb 2024 11:15:56 -0500 Subject: [PATCH 01/13] Remove the default bound from Packable::Visitor and replace const VERIFY with an Option --- .../fail/invalid_verify_with_field_type.rs | 4 +- .../fail/invalid_verify_with_struct_type.rs | 4 +- .../tests/pass/error_coercion.rs | 6 +-- .../tests/pass/verify_with_field.rs | 4 +- .../tests/pass/verify_with_field_visitor.rs | 6 +-- .../tests/pass/verify_with_struct.rs | 4 +- .../tests/pass/verify_with_struct_visitor.rs | 4 +- packable/packable-derive/src/enum_info.rs | 11 ++--- packable/packable-derive/src/fragments.rs | 23 +++------- packable/packable-derive/src/struct_info.rs | 30 ++----------- packable/packable-derive/src/trait_impl.rs | 10 ++--- .../src/unpack_visitor_info.rs | 6 +-- packable/packable/src/packable/array.rs | 6 +-- packable/packable/src/packable/bool.rs | 6 +-- packable/packable/src/packable/bounded.rs | 45 +++++++++++-------- packable/packable/src/packable/box.rs | 14 +++--- packable/packable/src/packable/map.rs | 20 ++++----- packable/packable/src/packable/mod.rs | 32 ++++++------- packable/packable/src/packable/num.rs | 16 +++---- packable/packable/src/packable/option.rs | 8 ++-- .../packable/src/packable/prefix/boxed.rs | 6 +-- .../packable/src/packable/prefix/btreeset.rs | 8 ++-- packable/packable/src/packable/prefix/map.rs | 20 ++++----- .../packable/src/packable/prefix/string.rs | 6 +-- packable/packable/src/packable/prefix/vec.rs | 8 ++-- .../packable/src/packable/primitive_types.rs | 6 +-- packable/packable/src/packable/set.rs | 8 ++-- packable/packable/src/packable/string.rs | 6 +-- packable/packable/src/packable/tuple.rs | 8 ++-- packable/packable/src/packable/vec.rs | 8 ++-- packable/packable/tests/common/mod.rs | 2 +- packable/packable/tests/counter.rs | 2 +- 32 files changed, 153 insertions(+), 194 deletions(-) diff --git a/packable/packable-derive-test/tests/fail/invalid_verify_with_field_type.rs b/packable/packable-derive-test/tests/fail/invalid_verify_with_field_type.rs index afb6397..df824f6 100644 --- a/packable/packable-derive-test/tests/fail/invalid_verify_with_field_type.rs +++ b/packable/packable-derive-test/tests/fail/invalid_verify_with_field_type.rs @@ -21,8 +21,8 @@ impl From for PickyError { } } -fn verify_value(&value: &u64) -> Result<(), PickyError> { - if !VERIFY || value == 42 { +fn verify_value(value: &u64, visitor: Option<&()>) -> Result<(), PickyError> { + if visitor.is_none() || value == 42 { Ok(()) } else { Err(PickyError(value as u8)) diff --git a/packable/packable-derive-test/tests/fail/invalid_verify_with_struct_type.rs b/packable/packable-derive-test/tests/fail/invalid_verify_with_struct_type.rs index 11cef43..47e2c9b 100644 --- a/packable/packable-derive-test/tests/fail/invalid_verify_with_struct_type.rs +++ b/packable/packable-derive-test/tests/fail/invalid_verify_with_struct_type.rs @@ -21,8 +21,8 @@ impl From for PickyError { } } -fn verify(&value: &u64) -> Result<(), PickyError> { - if !VERIFY || value == 42 { +fn verify(value: &u64, visitor: Option<&()>) -> Result<(), PickyError> { + if visitor.is_none() || value == 42 { Ok(()) } else { Err(PickyError(value as u8)) diff --git a/packable/packable-derive-test/tests/pass/error_coercion.rs b/packable/packable-derive-test/tests/pass/error_coercion.rs index 75a28f7..e86d5ae 100644 --- a/packable/packable-derive-test/tests/pass/error_coercion.rs +++ b/packable/packable-derive-test/tests/pass/error_coercion.rs @@ -31,11 +31,11 @@ impl Packable for Picky { self.0.pack(packer) } - fn unpack( + fn unpack( unpacker: &mut U, - visitor: &Self::UnpackVisitor, + visitor: Option<&Self::UnpackVisitor>, ) -> Result> { - let value = u8::unpack::<_, VERIFY>(unpacker, visitor).coerce()?; + let value = u8::unpack(unpacker, visitor).coerce()?; if value == 42 { Ok(Self(value)) diff --git a/packable/packable-derive-test/tests/pass/verify_with_field.rs b/packable/packable-derive-test/tests/pass/verify_with_field.rs index 0616e04..6d06b91 100644 --- a/packable/packable-derive-test/tests/pass/verify_with_field.rs +++ b/packable/packable-derive-test/tests/pass/verify_with_field.rs @@ -21,8 +21,8 @@ impl From for PickyError { } } -fn verify_value(&value: &u8) -> Result<(), PickyError> { - if !VERIFY || value == 42 { +fn verify_value(value: &u8, visitor: Option<&()>) -> Result<(), PickyError> { + if visitor.is_none() || value == 42 { Ok(()) } else { Err(PickyError(value)) diff --git a/packable/packable-derive-test/tests/pass/verify_with_field_visitor.rs b/packable/packable-derive-test/tests/pass/verify_with_field_visitor.rs index 1e6c67b..bb1fb79 100644 --- a/packable/packable-derive-test/tests/pass/verify_with_field_visitor.rs +++ b/packable/packable-derive-test/tests/pass/verify_with_field_visitor.rs @@ -21,11 +21,11 @@ impl From for PickyError { } } -fn verify_value(&value: &u8, _: &()) -> Result<(), PickyError> { - if !VERIFY || value == 42 { +fn verify(value: &u64, visitor: Option<&()>) -> Result<(), PickyError> { + if visitor.is_none() || value == 42 { Ok(()) } else { - Err(PickyError(value)) + Err(PickyError(value as u8)) } } diff --git a/packable/packable-derive-test/tests/pass/verify_with_struct.rs b/packable/packable-derive-test/tests/pass/verify_with_struct.rs index 13ecead..f0ef8eb 100644 --- a/packable/packable-derive-test/tests/pass/verify_with_struct.rs +++ b/packable/packable-derive-test/tests/pass/verify_with_struct.rs @@ -21,8 +21,8 @@ impl From for PickyError { } } -fn verify(value: &Picky) -> Result<(), PickyError> { - if !VERIFY || value.0 == 42 { +fn verify(value: &Picky, visitor: Option<&()>) -> Result<(), PickyError> { + if visitor.is_none() || value.0 == 42 { Ok(()) } else { Err(PickyError(value.0)) diff --git a/packable/packable-derive-test/tests/pass/verify_with_struct_visitor.rs b/packable/packable-derive-test/tests/pass/verify_with_struct_visitor.rs index 2e8b20c..daf9c6e 100644 --- a/packable/packable-derive-test/tests/pass/verify_with_struct_visitor.rs +++ b/packable/packable-derive-test/tests/pass/verify_with_struct_visitor.rs @@ -21,8 +21,8 @@ impl From for PickyError { } } -fn verify(value: &Picky, _: &()) -> Result<(), PickyError> { - if !VERIFY || value.0 == 42 { +fn verify(value: &Picky, visitor: Option<&()>) -> Result<(), PickyError> { + if visitor.is_none() || value.0 == 42 { Ok(()) } else { Err(PickyError(value.0)) diff --git a/packable/packable-derive/src/enum_info.rs b/packable/packable-derive/src/enum_info.rs index 6966a05..e9643e9 100644 --- a/packable/packable-derive/src/enum_info.rs +++ b/packable/packable-derive/src/enum_info.rs @@ -34,20 +34,17 @@ impl EnumInfo { )?; let unpack_visitor = UnpackVisitorInfo::new(filtered_attrs, || { - let (unpack_visitor, explicit) = match data + let unpack_visitor = match data .variants .iter() .next() .and_then(|variant| variant.fields.iter().next()) { - Some(Field { ty, .. }) => (parse_quote!(<#ty as #crate_name::Packable>::UnpackVisitor), true), - None => (parse_quote!(()), false), + Some(Field { ty, .. }) => parse_quote!(<#ty as #crate_name::Packable>::UnpackVisitor), + None => parse_quote!(()), }; - Ok(UnpackVisitorInfo { - unpack_visitor, - explicit, - }) + Ok(UnpackVisitorInfo { unpack_visitor }) })?; let variants_info = data diff --git a/packable/packable-derive/src/fragments.rs b/packable/packable-derive/src/fragments.rs index 077a9f7..e53b3a7 100644 --- a/packable/packable-derive/src/fragments.rs +++ b/packable/packable-derive/src/fragments.rs @@ -5,7 +5,7 @@ use proc_macro2::TokenStream; use quote::quote; use syn::{Ident, Path}; -use crate::{record_info::RecordInfo, unpack_visitor_info::UnpackVisitorInfo}; +use crate::record_info::RecordInfo; pub(crate) struct Fragments { // The pattern used to destructure the record. @@ -17,12 +17,7 @@ pub(crate) struct Fragments { } impl Fragments { - pub(crate) fn new( - info: RecordInfo, - verify_with: Option, - unpack_visitor_info: &UnpackVisitorInfo, - crate_name: &Ident, - ) -> Self { + pub(crate) fn new(info: RecordInfo, verify_with: Option, crate_name: &Ident) -> Self { let RecordInfo { path, fields_unpack_error_with, @@ -33,21 +28,13 @@ impl Fragments { } = info; let fields_verification = fields_verify_with.into_iter().zip(fields_ident.iter()).map(|(verify_with, field_ident)| match verify_with { - Some(verify_with) => if unpack_visitor_info.explicit { - quote!(#verify_with::(&#field_ident, visitor).map_err(#crate_name::error::UnpackError::from_packable)?;) - } else { - quote!(#verify_with::(&#field_ident).map_err(#crate_name::error::UnpackError::from_packable)?;) - } + Some(verify_with) => quote!(#verify_with(&#field_ident, visitor).map_err(#crate_name::error::UnpackError::from_packable)?;), None => quote!(), }); let verify_with = match verify_with { Some(verify_with) => { - if unpack_visitor_info.explicit { - quote!(#verify_with::(&unpacked, visitor).map_err(#crate_name::error::UnpackError::from_packable)?;) - } else { - quote!(#verify_with::(&unpacked).map_err(#crate_name::error::UnpackError::from_packable)?;) - } + quote!(#verify_with(&unpacked, visitor).map_err(#crate_name::error::UnpackError::from_packable)?;) } None => quote!(), }; @@ -60,7 +47,7 @@ impl Fragments { }, unpack: quote! { #( - let #fields_ident = <#fields_type as #crate_name::Packable>::unpack::<_, VERIFY>(unpacker, Borrow::<<#fields_type as #crate_name::Packable>::UnpackVisitor>::borrow(visitor)).map_packable_err(#fields_unpack_error_with).coerce()?; + let #fields_ident = <#fields_type as #crate_name::Packable>::unpack(unpacker, visitor.map(Borrow::<<#fields_type as #crate_name::Packable>::UnpackVisitor>::borrow)).map_packable_err(#fields_unpack_error_with).coerce()?; #fields_verification )* diff --git a/packable/packable-derive/src/struct_info.rs b/packable/packable-derive/src/struct_info.rs index 0775b09..d194cda 100644 --- a/packable/packable-derive/src/struct_info.rs +++ b/packable/packable-derive/src/struct_info.rs @@ -42,34 +42,12 @@ impl StructInfo { } let unpack_visitor = UnpackVisitorInfo::new(filtered_attrs, || { - let (unpack_visitor, explicit) = match fields.iter().next() { - Some(Field { attrs, ty, .. }) => { - let mut explicit = false; - - for attr in filter_attrs(attrs) { - explicit = attr - .parse_args_with(|stream: ParseStream| { - let opt = parse_kv::("unpack_visitor", stream)?; - if opt.is_none() { - skip_stream(stream)?; - } - Ok(opt) - })? - .is_some(); - if explicit { - break; - } - } - - (parse_quote!(<#ty as #crate_name::Packable>::UnpackVisitor), explicit) - } - None => (parse_quote!(()), false), + let unpack_visitor = match fields.iter().next() { + Some(Field { ty, .. }) => parse_quote!(<#ty as #crate_name::Packable>::UnpackVisitor), + None => parse_quote!(()), }; - Ok(UnpackVisitorInfo { - unpack_visitor, - explicit, - }) + Ok(UnpackVisitorInfo { unpack_visitor }) })?; let inner = RecordInfo::new(path, fields, &unpack_error.with)?; diff --git a/packable/packable-derive/src/trait_impl.rs b/packable/packable-derive/src/trait_impl.rs index 48002cc..a5c1687 100644 --- a/packable/packable-derive/src/trait_impl.rs +++ b/packable/packable-derive/src/trait_impl.rs @@ -29,8 +29,7 @@ impl TraitImpl { let unpack_error = info.unpack_error.unpack_error.clone().into_token_stream(); let unpack_visitor = info.unpack_visitor.unpack_visitor.clone().into_token_stream(); - let Fragments { pattern, pack, unpack } = - Fragments::new(info.inner, info.verify_with, &info.unpack_visitor, &crate_name); + let Fragments { pattern, pack, unpack } = Fragments::new(info.inner, info.verify_with, &crate_name); Ok(Self { ident: input.ident, @@ -66,8 +65,7 @@ impl TraitImpl { for (index, VariantInfo { tag, inner }) in info.variants_info.into_iter().enumerate() { let variant_ident = inner.path.segments.last().unwrap().clone(); - let Fragments { pattern, pack, unpack } = - Fragments::new(inner, None, &info.unpack_visitor, &crate_name); + let Fragments { pattern, pack, unpack } = Fragments::new(inner, None, &crate_name); // @pvdrz: The span here is very important, otherwise the compiler won't detect // unreachable patterns in the generated code for some reason. I think this is related @@ -113,7 +111,7 @@ impl TraitImpl { #(#tag_decls)* #(#tag_asserts)* - match <#tag_type as #crate_name::Packable>::unpack::<_, VERIFY>(unpacker, Borrow::<<#tag_type as #crate_name::Packable>::UnpackVisitor>::borrow(visitor)).coerce()? { + match <#tag_type as #crate_name::Packable>::unpack(unpacker, visitor.map(Borrow::<<#tag_type as #crate_name::Packable>::UnpackVisitor>::borrow)).coerce()? { #(#unpack_arms)* tag => Err(#crate_name::error::UnpackError::from_packable(#tag_with_error(tag))) } @@ -153,7 +151,7 @@ impl ToTokens for TraitImpl { #pack } - fn unpack(unpacker: &mut U, visitor: &Self::UnpackVisitor) -> Result> { + fn unpack(unpacker: &mut U, visitor: Option<&Self::UnpackVisitor>) -> Result> { use #crate_name::error::UnpackErrorExt; use core::borrow::Borrow; #unpack diff --git a/packable/packable-derive/src/unpack_visitor_info.rs b/packable/packable-derive/src/unpack_visitor_info.rs index 15c29ea..e12e2ed 100644 --- a/packable/packable-derive/src/unpack_visitor_info.rs +++ b/packable/packable-derive/src/unpack_visitor_info.rs @@ -10,7 +10,6 @@ use crate::parse::{parse_kv, skip_stream}; pub(crate) struct UnpackVisitorInfo { pub(crate) unpack_visitor: syn::Type, - pub(crate) explicit: bool, } struct Type(syn::Type); @@ -35,10 +34,7 @@ impl UnpackVisitorInfo { let opt_info = attr.parse_args_with( |stream: ParseStream| match parse_kv::("unpack_visitor", stream)? { - Some(Type(unpack_visitor)) => Ok(Some(Self { - unpack_visitor, - explicit: true, - })), + Some(Type(unpack_visitor)) => Ok(Some(Self { unpack_visitor })), None => { skip_stream(stream)?; Ok(None) diff --git a/packable/packable/src/packable/array.rs b/packable/packable/src/packable/array.rs index 28e523c..42bdd9a 100644 --- a/packable/packable/src/packable/array.rs +++ b/packable/packable/src/packable/array.rs @@ -25,9 +25,9 @@ impl Packable for [T; N] { } #[inline] - fn unpack( + fn unpack( unpacker: &mut U, - visitor: &Self::UnpackVisitor, + visitor: Option<&Self::UnpackVisitor>, ) -> Result> { if TypeId::of::() == TypeId::of::() { let mut bytes = [0u8; N]; @@ -40,7 +40,7 @@ impl Packable for [T; N] { let mut array = unsafe { MaybeUninit::<[MaybeUninit; N]>::uninit().assume_init() }; for item in array.iter_mut() { - let unpacked = T::unpack::<_, VERIFY>(unpacker, visitor)?; + let unpacked = T::unpack(unpacker, visitor)?; // Safety: each `item` is only visited once so we are never overwriting nor dropping values that are // already initialized. diff --git a/packable/packable/src/packable/bool.rs b/packable/packable/src/packable/bool.rs index 2f709c3..f86f82e 100644 --- a/packable/packable/src/packable/bool.rs +++ b/packable/packable/src/packable/bool.rs @@ -22,10 +22,10 @@ impl Packable for bool { /// Booleans are unpacked if the byte used to represent them is non-zero. #[inline] - fn unpack( + fn unpack( unpacker: &mut U, - visitor: &Self::UnpackVisitor, + visitor: Option<&Self::UnpackVisitor>, ) -> Result> { - Ok(u8::unpack::<_, VERIFY>(unpacker, visitor).coerce()? != 0) + Ok(u8::unpack(unpacker, visitor).coerce()? != 0) } } diff --git a/packable/packable/src/packable/bounded.rs b/packable/packable/src/packable/bounded.rs index 4752584..95e7206 100644 --- a/packable/packable/src/packable/bounded.rs +++ b/packable/packable/src/packable/bounded.rs @@ -23,10 +23,7 @@ macro_rules! bounded { #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, Packable)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] #[packable(unpack_error = $invalid_error)] - pub struct $wrapper( - #[packable(verify_with = Self::verify)] - $ty - ); + pub struct $wrapper(#[packable(verify_with = Self::verify)] $ty); impl Bounded for $wrapper { type Bounds = $ty; @@ -44,9 +41,9 @@ macro_rules! bounded { self.0 } - fn verify(&value: &$ty) -> Result<(), $invalid_error> { - if VERIFY && !(MIN..=MAX).contains(&value) { - Err($invalid_error(value)) + fn verify(value: &$ty, visitor: Option<&()>) -> Result<(), $invalid_error> { + if visitor.is_some() && !(MIN..=MAX).contains(value) { + Err($invalid_error(*value)) } else { Ok(()) } @@ -70,7 +67,7 @@ macro_rules! bounded { type Error = $invalid_error; fn try_from(value: $ty) -> Result { - Self::verify::(&value)?; + // Self::verify(&value, Some(&()))?; Ok(Self(value)) } } @@ -85,8 +82,9 @@ macro_rules! bounded { } } - #[doc = concat!("Error encountered when attempting to wrap a [`", stringify!($ty),"`] that is not within the given bounds.")] - #[derive(Debug, Clone, Copy, PartialEq, Eq, )] + #[doc = concat!("Error encountered when attempting to wrap a [`", stringify!($ty),"`] that is not within the + given bounds.")] + #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub struct $invalid_error(pub $ty); #[cfg(feature = "std")] @@ -94,7 +92,11 @@ macro_rules! bounded { impl Display for $invalid_error { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - write!(f, "the integer `{}` is out of bounds (`{}..={}`)", self.0, MIN, MAX) + write!( + f, + "the integer `{}` is out of bounds (`{}..={}`)", + self.0, MIN, MAX + ) } } @@ -110,10 +112,12 @@ macro_rules! bounded { } } - #[doc = concat!("Error encountered when attempting to convert a [`usize`] into a [`", stringify!($wrapper),"`].")] + #[doc = concat!("Error encountered when attempting to convert a [`usize`] into a [`", + stringify!($wrapper),"`].")] #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum $try_error { - #[doc = concat!("The `usize` could be converted into a [`", stringify!($ty),"`] but it is not within the given bounds.")] + #[doc = concat!("The `usize` could be converted into a [`", stringify!($ty),"`] but it is not within the + given bounds.")] Invalid($ty), #[doc = concat!("The `usize` could not be converted into a [`", stringify!($ty),"`].")] Truncated(usize), @@ -123,13 +127,18 @@ macro_rules! bounded { impl std::error::Error for $try_error {} impl Display for $try_error { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - match self { - Self::Truncated(len) => write!(f, "the integer `{}` was truncated while casting it into a `{}`", len, core::any::type_name::<$ty>()), - Self::Invalid(err) => $invalid_error::(*err).fmt(f), + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + Self::Truncated(len) => write!( + f, + "the integer `{}` was truncated while casting it into a `{}`", + len, + core::any::type_name::<$ty>() + ), + Self::Invalid(err) => $invalid_error::(*err).fmt(f), + } } } -} impl From<$invalid_error> for $try_error { fn from(err: $invalid_error) -> Self { diff --git a/packable/packable/src/packable/box.rs b/packable/packable/src/packable/box.rs index fdee462..25e7beb 100644 --- a/packable/packable/src/packable/box.rs +++ b/packable/packable/src/packable/box.rs @@ -22,11 +22,11 @@ impl Packable for Box { } #[inline] - fn unpack( + fn unpack( unpacker: &mut U, - visitor: &Self::UnpackVisitor, + visitor: Option<&Self::UnpackVisitor>, ) -> Result> { - Ok(Box::new(T::unpack::<_, VERIFY>(unpacker, visitor)?)) + Ok(Box::new(T::unpack(unpacker, visitor)?)) } } @@ -54,13 +54,13 @@ impl Packable for Box<[T]> { } #[inline] - fn unpack( + fn unpack( unpacker: &mut U, - visitor: &Self::UnpackVisitor, + visitor: Option<&Self::UnpackVisitor>, ) -> Result> { use crate::error::UnpackErrorExt; - let len = u64::unpack::<_, VERIFY>(unpacker, &()) + let len = u64::unpack(unpacker, None) .coerce()? .try_into() .map_err(|err| UnpackError::Packable(Self::UnpackError::Prefix(err)))?; @@ -74,7 +74,7 @@ impl Packable for Box<[T]> { let mut vec = Vec::with_capacity(len); for _ in 0..len { - let item = T::unpack::<_, VERIFY>(unpacker, visitor).map_packable_err(Self::UnpackError::Item)?; + let item = T::unpack(unpacker, visitor).map_packable_err(Self::UnpackError::Item)?; vec.push(item); } diff --git a/packable/packable/src/packable/map.rs b/packable/packable/src/packable/map.rs index bd3ad09..1a6ec7b 100644 --- a/packable/packable/src/packable/map.rs +++ b/packable/packable/src/packable/map.rs @@ -137,13 +137,13 @@ where } #[inline] - fn unpack( + fn unpack( unpacker: &mut U, - visitor: &Self::UnpackVisitor, + visitor: Option<&Self::UnpackVisitor>, ) -> Result> { use crate::error::UnpackErrorExt; - let len = u64::unpack::<_, VERIFY>(unpacker, &()) + let len = u64::unpack(unpacker, None) .coerce()? .try_into() .map_err(|err| UnpackError::Packable(UnpackMapError::Prefix(err)))?; @@ -151,7 +151,7 @@ where let mut map = HashMap::::with_capacity(len); for _ in 0..len { - let key = K::unpack::<_, VERIFY>(unpacker, visitor.borrow()) + let key = K::unpack(unpacker, visitor.map(Borrow::borrow)) .map_packable_err(UnpackMapError::Key) .map_packable_err(Self::UnpackError::from)?; @@ -159,7 +159,7 @@ where return Err(UnpackError::Packable(UnpackMapError::DuplicateKey(key))); } - let value = V::unpack::<_, VERIFY>(unpacker, visitor) + let value = V::unpack(unpacker, visitor) .map_packable_err(UnpackMapError::Value) .map_packable_err(Self::UnpackError::from)?; @@ -192,13 +192,13 @@ where } #[inline] - fn unpack( + fn unpack( unpacker: &mut U, - visitor: &Self::UnpackVisitor, + visitor: Option<&Self::UnpackVisitor>, ) -> Result> { use crate::error::UnpackErrorExt; - let len = u64::unpack::<_, VERIFY>(unpacker, &()) + let len = u64::unpack(unpacker, None) .coerce()? .try_into() .map_err(|err| UnpackError::Packable(UnpackMapError::Prefix(err).into()))?; @@ -206,7 +206,7 @@ where let mut map = BTreeMap::::new(); for _ in 0..len { - let key = K::unpack::<_, VERIFY>(unpacker, visitor.borrow()) + let key = K::unpack(unpacker, visitor.map(Borrow::borrow)) .map_packable_err(UnpackMapError::Key) .map_packable_err(Self::UnpackError::from)?; @@ -224,7 +224,7 @@ where } } - let value = V::unpack::<_, VERIFY>(unpacker, visitor) + let value = V::unpack(unpacker, visitor) .map_packable_err(UnpackMapError::Value) .map_packable_err(Self::UnpackError::from)?; diff --git a/packable/packable/src/packable/mod.rs b/packable/packable/src/packable/mod.rs index 6498438..a5b8c4d 100644 --- a/packable/packable/src/packable/mod.rs +++ b/packable/packable/src/packable/mod.rs @@ -80,15 +80,13 @@ use crate::{ /// } /// } /// -/// fn unpack( +/// fn unpack( /// unpacker: &mut U, -/// visitor: &Self::UnpackVisitor, +/// visitor: Option<&Self::UnpackVisitor>, /// ) -> Result> { -/// match u8::unpack::<_, VERIFY>(unpacker, visitor).coerce()? { +/// match u8::unpack(unpacker, visitor).coerce()? { /// 0u8 => Ok(Self::Nothing), -/// 1u8 => Ok(Self::Just( -/// i32::unpack::<_, VERIFY>(unpacker, visitor).coerce()?, -/// )), +/// 1u8 => Ok(Self::Just(i32::unpack(unpacker, visitor).coerce()?)), /// tag => Err(UnpackError::Packable(UnknownTagError(tag))), /// } /// } @@ -174,11 +172,10 @@ use crate::{ /// `#[packable(verify_with = ...)]` attribute which must receive a valid Rust path refering to a /// function with the signature /// ```ignore -/// fn(field: &F) -> Result<(), P::UnpackError> +/// fn(field: &F, visitor: Option<&P::UnpackVisitor>) -> Result<(), P::UnpackError> /// ``` -/// where `F` is the type of the field being verified, `P` is the type of the `struct` or `enum` -/// and `VERIFY` is the same constant parameter used inside `Packable::unpack`. This verification -/// function will be run immediately after unpacking the field. +/// where `F` is the type of the field being verified, `P` is the type of the `struct` or `enum`. +/// This verification function will be run immediately after unpacking the field. pub trait Packable: Sized + 'static { /// The error type that can be returned if some semantic error occurs while unpacking. /// @@ -186,16 +183,16 @@ pub trait Packable: Sized + 'static { /// [`UnknownTagError`](crate::error::UnknownTagError) when implementing this trait for an enum. type UnpackError: Debug + From; /// FIXME: docs - type UnpackVisitor: Default + Borrow<()>; + type UnpackVisitor: Borrow<()>; /// Packs this value into the given [`Packer`]. fn pack(&self, packer: &mut P) -> Result<(), P::Error>; - /// Unpacks this value from the given [`Unpacker`]. The `VERIFY` generic parameter can be used to skip additional + /// Unpacks this value from the given [`Unpacker`]. The optional visitor can be used to skip additional /// syntactic checks. - fn unpack( + fn unpack( unpacker: &mut U, - visitor: &Self::UnpackVisitor, + visitor: Option<&Self::UnpackVisitor>, ) -> Result>; } @@ -247,7 +244,7 @@ impl PackableExt for P { bytes: T, visitor: &P::UnpackVisitor, ) -> Result::UnpackError, UnexpectedEOF>> { - Self::unpack::<_, true>(&mut SliceUnpacker::new(bytes.as_ref()), visitor) + Self::unpack(&mut SliceUnpacker::new(bytes.as_ref()), Some(visitor)) } /// Unpacks this value from a type that implements [`AsRef<[u8]>`] skipping some syntatical checks. @@ -255,9 +252,6 @@ impl PackableExt for P { fn unpack_unverified>( bytes: T, ) -> Result::UnpackError, UnexpectedEOF>> { - Self::unpack::<_, false>( - &mut SliceUnpacker::new(bytes.as_ref()), - &

::UnpackVisitor::default(), - ) + Self::unpack(&mut SliceUnpacker::new(bytes.as_ref()), None) } } diff --git a/packable/packable/src/packable/num.rs b/packable/packable/src/packable/num.rs index a48a78b..c34a4fa 100644 --- a/packable/packable/src/packable/num.rs +++ b/packable/packable/src/packable/num.rs @@ -17,9 +17,9 @@ macro_rules! impl_packable_for_num { } #[inline] - fn unpack( + fn unpack( unpacker: &mut U, - (): &Self::UnpackVisitor, + _: Option<&Self::UnpackVisitor>, ) -> Result> { let mut bytes = [0u8; core::mem::size_of::()]; unpacker.unpack_bytes(&mut bytes)?; @@ -63,12 +63,12 @@ impl Packable for usize { } #[inline] - fn unpack( + fn unpack( unpacker: &mut U, - visitor: &Self::UnpackVisitor, + visitor: Option<&Self::UnpackVisitor>, ) -> Result> { use crate::error::UnpackErrorExt; - Self::try_from(u64::unpack::<_, VERIFY>(unpacker, visitor).coerce()?).map_err(UnpackError::Packable) + Self::try_from(u64::unpack(unpacker, visitor).coerce()?).map_err(UnpackError::Packable) } } @@ -83,11 +83,11 @@ impl Packable for isize { } #[inline] - fn unpack( + fn unpack( unpacker: &mut U, - visitor: &Self::UnpackVisitor, + visitor: Option<&Self::UnpackVisitor>, ) -> Result> { use crate::error::UnpackErrorExt; - Self::try_from(i64::unpack::<_, VERIFY>(unpacker, visitor).coerce()?).map_err(UnpackError::Packable) + Self::try_from(i64::unpack(unpacker, visitor).coerce()?).map_err(UnpackError::Packable) } } diff --git a/packable/packable/src/packable/option.rs b/packable/packable/src/packable/option.rs index fd72f74..d4c239d 100644 --- a/packable/packable/src/packable/option.rs +++ b/packable/packable/src/packable/option.rs @@ -54,14 +54,14 @@ impl Packable for Option { } } - fn unpack( + fn unpack( unpacker: &mut U, - visitor: &Self::UnpackVisitor, + visitor: Option<&Self::UnpackVisitor>, ) -> Result> { - match u8::unpack::<_, VERIFY>(unpacker, &()).coerce()? { + match u8::unpack(unpacker, None).coerce()? { 0 => Ok(None), 1 => Ok(Some( - T::unpack::<_, VERIFY>(unpacker, visitor).map_packable_err(UnpackOptionError::Inner)?, + T::unpack(unpacker, visitor).map_packable_err(UnpackOptionError::Inner)?, )), n => Err(UnpackError::Packable(Self::UnpackError::UnknownTag(n))), } diff --git a/packable/packable/src/packable/prefix/boxed.rs b/packable/packable/src/packable/prefix/boxed.rs index fa68151..9fecf16 100644 --- a/packable/packable/src/packable/prefix/boxed.rs +++ b/packable/packable/src/packable/prefix/boxed.rs @@ -114,11 +114,11 @@ where } #[inline] - fn unpack( + fn unpack( unpacker: &mut U, - visitor: &Self::UnpackVisitor, + visitor: Option<&Self::UnpackVisitor>, ) -> Result> { - let vec: Vec = VecPrefix::::unpack::<_, VERIFY>(unpacker, visitor)?.into(); + let vec: Vec = VecPrefix::::unpack(unpacker, visitor)?.into(); Ok(Self { inner: vec.into_boxed_slice(), diff --git a/packable/packable/src/packable/prefix/btreeset.rs b/packable/packable/src/packable/prefix/btreeset.rs index 800e152..25e29a6 100644 --- a/packable/packable/src/packable/prefix/btreeset.rs +++ b/packable/packable/src/packable/prefix/btreeset.rs @@ -106,14 +106,14 @@ where } #[inline] - fn unpack( + fn unpack( unpacker: &mut U, - visitor: &Self::UnpackVisitor, + visitor: Option<&Self::UnpackVisitor>, ) -> Result> { use crate::error::UnpackErrorExt; // The length of any dynamically-sized sequence must be prefixed. - let len = B::unpack::<_, VERIFY>(unpacker, &()) + let len = B::unpack(unpacker, None) .map_packable_err(UnpackSetError::Prefix) .map_packable_err(Self::UnpackError::from)? .into(); @@ -121,7 +121,7 @@ where let mut set = BTreeSet::::new(); for _ in B::Bounds::default()..len { - let item = T::unpack::<_, VERIFY>(unpacker, visitor) + let item = T::unpack(unpacker, visitor) .map_packable_err(UnpackSetError::Item) .map_packable_err(Self::UnpackError::from)?; diff --git a/packable/packable/src/packable/prefix/map.rs b/packable/packable/src/packable/prefix/map.rs index f42d672..7f6f20e 100644 --- a/packable/packable/src/packable/prefix/map.rs +++ b/packable/packable/src/packable/prefix/map.rs @@ -111,14 +111,14 @@ where } #[inline] - fn unpack( + fn unpack( unpacker: &mut U, - visitor: &Self::UnpackVisitor, + visitor: Option<&Self::UnpackVisitor>, ) -> Result> { use crate::error::UnpackErrorExt; // The length of any dynamically-sized sequence must be prefixed. - let len = B::unpack::<_, VERIFY>(unpacker, &()) + let len = B::unpack(unpacker, None) .map_packable_err(UnpackMapError::Prefix) .map_packable_err(Self::UnpackError::from)? .into(); @@ -126,7 +126,7 @@ where let mut map = HashMap::::new(); for _ in B::Bounds::default()..len { - let key = K::unpack::<_, VERIFY>(unpacker, visitor.borrow()) + let key = K::unpack(unpacker, visitor.map(Borrow::borrow)) .map_packable_err(UnpackMapError::Key) .map_packable_err(Self::UnpackError::from)?; @@ -134,7 +134,7 @@ where return Err(UnpackError::Packable(UnpackMapError::DuplicateKey(key))); } - let value = V::unpack::<_, VERIFY>(unpacker, visitor) + let value = V::unpack(unpacker, visitor) .map_packable_err(UnpackMapError::Value) .map_packable_err(Self::UnpackError::from)?; @@ -236,14 +236,14 @@ where } #[inline] - fn unpack( + fn unpack( unpacker: &mut U, - visitor: &Self::UnpackVisitor, + visitor: Option<&Self::UnpackVisitor>, ) -> Result> { use crate::error::UnpackErrorExt; // The length of any dynamically-sized sequence must be prefixed. - let len = B::unpack::<_, VERIFY>(unpacker, &()) + let len = B::unpack(unpacker, None) .map_packable_err(UnpackMapError::Prefix) .map_packable_err(Self::UnpackError::from)? .into(); @@ -251,7 +251,7 @@ where let mut map = BTreeMap::::new(); for _ in B::Bounds::default()..len { - let key = K::unpack::<_, VERIFY>(unpacker, visitor.borrow()) + let key = K::unpack(unpacker, visitor.map(Borrow::borrow)) .map_packable_err(UnpackMapError::Key) .map_packable_err(Self::UnpackError::from)?; @@ -269,7 +269,7 @@ where } } - let value = V::unpack::<_, VERIFY>(unpacker, visitor) + let value = V::unpack(unpacker, visitor) .map_packable_err(UnpackMapError::Value) .map_packable_err(Self::UnpackError::from)?; diff --git a/packable/packable/src/packable/prefix/string.rs b/packable/packable/src/packable/prefix/string.rs index 4bf5377..aa7c3bf 100644 --- a/packable/packable/src/packable/prefix/string.rs +++ b/packable/packable/src/packable/prefix/string.rs @@ -101,12 +101,12 @@ where } #[inline] - fn unpack( + fn unpack( unpacker: &mut U, - visitor: &Self::UnpackVisitor, + visitor: Option<&Self::UnpackVisitor>, ) -> Result> { // The length of any dynamically-sized sequence must be prefixed. - let len = B::unpack::<_, VERIFY>(unpacker, visitor) + let len = B::unpack(unpacker, visitor) .map_packable_err(UnpackPrefixError::Prefix)? .into(); diff --git a/packable/packable/src/packable/prefix/vec.rs b/packable/packable/src/packable/prefix/vec.rs index ba4d3c9..28492dc 100644 --- a/packable/packable/src/packable/prefix/vec.rs +++ b/packable/packable/src/packable/prefix/vec.rs @@ -110,12 +110,12 @@ where } #[inline] - fn unpack( + fn unpack( unpacker: &mut U, - visitor: &Self::UnpackVisitor, + visitor: Option<&Self::UnpackVisitor>, ) -> Result> { // The length of any dynamically-sized sequence must be prefixed. - let len = B::unpack::<_, VERIFY>(unpacker, &()) + let len = B::unpack(unpacker, None) .map_packable_err(UnpackPrefixError::Prefix)? .into(); @@ -143,7 +143,7 @@ where let mut inner = Vec::with_capacity(len.try_into().unwrap_or(0)); for _ in B::Bounds::default()..len { - let item = T::unpack::<_, VERIFY>(unpacker, visitor).map_packable_err(Self::UnpackError::Item)?; + let item = T::unpack(unpacker, visitor).map_packable_err(Self::UnpackError::Item)?; inner.push(item); } diff --git a/packable/packable/src/packable/primitive_types.rs b/packable/packable/src/packable/primitive_types.rs index 7f4d976..2629f12 100644 --- a/packable/packable/src/packable/primitive_types.rs +++ b/packable/packable/src/packable/primitive_types.rs @@ -17,10 +17,10 @@ impl Packable for U256 { } #[inline] - fn unpack( + fn unpack( unpacker: &mut U, - visitor: &Self::UnpackVisitor, + visitor: Option<&Self::UnpackVisitor>, ) -> Result> { - <[u64; 4]>::unpack::<_, VERIFY>(unpacker, visitor).map(Self) + <[u64; 4]>::unpack(unpacker, visitor).map(Self) } } diff --git a/packable/packable/src/packable/set.rs b/packable/packable/src/packable/set.rs index 1ed7e57..91f4cd2 100644 --- a/packable/packable/src/packable/set.rs +++ b/packable/packable/src/packable/set.rs @@ -122,13 +122,13 @@ mod btreeset { } #[inline] - fn unpack( + fn unpack( unpacker: &mut U, - visitor: &Self::UnpackVisitor, + visitor: Option<&Self::UnpackVisitor>, ) -> Result> { use crate::error::UnpackErrorExt; - let len = u64::unpack::<_, VERIFY>(unpacker, &()) + let len = u64::unpack(unpacker, None) .coerce()? .try_into() .map_err(|err| UnpackError::Packable(UnpackSetError::Prefix(err).into()))?; @@ -136,7 +136,7 @@ mod btreeset { let mut set = BTreeSet::::new(); for _ in 0..len { - let item = T::unpack::<_, VERIFY>(unpacker, visitor) + let item = T::unpack(unpacker, visitor) .map_packable_err(UnpackSetError::Item) .map_packable_err(Self::UnpackError::from)?; diff --git a/packable/packable/src/packable/string.rs b/packable/packable/src/packable/string.rs index 6c4fc6e..ed79c8d 100644 --- a/packable/packable/src/packable/string.rs +++ b/packable/packable/src/packable/string.rs @@ -32,11 +32,11 @@ impl Packable for String { } #[inline] - fn unpack( + fn unpack( unpacker: &mut U, - visitor: &Self::UnpackVisitor, + visitor: Option<&Self::UnpackVisitor>, ) -> Result> { - let bytes = Vec::::unpack::<_, VERIFY>(unpacker, visitor) + let bytes = Vec::::unpack(unpacker, visitor) .map_packable_err(|err| UnpackPrefixError::Prefix(err.into_prefix_err()))?; String::from_utf8(bytes).map_err(|e| UnpackError::Packable(Self::UnpackError::Item(e))) diff --git a/packable/packable/src/packable/tuple.rs b/packable/packable/src/packable/tuple.rs index 71d9415..4e2efb0 100644 --- a/packable/packable/src/packable/tuple.rs +++ b/packable/packable/src/packable/tuple.rs @@ -28,13 +28,13 @@ macro_rules! tuple_impls { Ok(()) } - fn unpack( + fn unpack( unpacker: &mut U, - visitor: &Self::UnpackVisitor, + visitor: Option<&Self::UnpackVisitor>, ) -> Result> { Ok(( - <$FirstT>::unpack::<_, VERIFY>(unpacker, visitor)?, - $( (<$T>::unpack::<_, VERIFY>(unpacker, visitor.borrow()).map_packable_err(Into::into))?,)* + <$FirstT>::unpack(unpacker, visitor)?, + $( (<$T>::unpack(unpacker, visitor.map(core::borrow::Borrow::borrow)).map_packable_err(Into::into))?,)* )) } } diff --git a/packable/packable/src/packable/vec.rs b/packable/packable/src/packable/vec.rs index eb62be0..8f6b57f 100644 --- a/packable/packable/src/packable/vec.rs +++ b/packable/packable/src/packable/vec.rs @@ -40,11 +40,11 @@ where } #[inline] - fn unpack( + fn unpack( unpacker: &mut U, - visitor: &Self::UnpackVisitor, + visitor: Option<&Self::UnpackVisitor>, ) -> Result> { - let len = u64::unpack::<_, VERIFY>(unpacker, &()) + let len = u64::unpack(unpacker, None) .coerce()? .try_into() .map_err(|err| UnpackError::Packable(UnpackPrefixError::Prefix(err)))?; @@ -58,7 +58,7 @@ where let mut vec = Vec::with_capacity(len); for _ in 0..len { - let item = T::unpack::<_, VERIFY>(unpacker, visitor).map_packable_err(Self::UnpackError::Item)?; + let item = T::unpack(unpacker, visitor).map_packable_err(Self::UnpackError::Item)?; vec.push(item); } diff --git a/packable/packable/tests/common/mod.rs b/packable/packable/tests/common/mod.rs index af7136f..9cce1aa 100644 --- a/packable/packable/tests/common/mod.rs +++ b/packable/packable/tests/common/mod.rs @@ -60,7 +60,7 @@ where let mut packer = IoPacker::new(Vec::new()); packable.pack(&mut packer).unwrap(); let mut unpacker = IoUnpacker::new(packer.as_slice()); - let unpacked = P::unpack::<_, true>(&mut unpacker, &()).unwrap(); + let unpacked = P::unpack(&mut unpacker, None).unwrap(); assert_eq!(packable, &unpacked); generic_test_pack_to_slice_unpack_verified(packable); diff --git a/packable/packable/tests/counter.rs b/packable/packable/tests/counter.rs index 8bb2179..a6d325d 100644 --- a/packable/packable/tests/counter.rs +++ b/packable/packable/tests/counter.rs @@ -19,7 +19,7 @@ fn option_counter() { let packer = packer.into_inner(); let mut unpacker = CounterUnpacker::new(SliceUnpacker::new(packer.as_slice())); - let unpacked_value = Option::::unpack::<_, true>(&mut unpacker, &()).unwrap(); + let unpacked_value = Option::::unpack(&mut unpacker, None).unwrap(); assert_eq!(unpacked_value.packed_len(), unpacker.counter()); assert_eq!(unpacker.counter(), unpacker.read_bytes().unwrap()); assert_eq!(value, unpacked_value); From 8c25efd27539559aab69901da1163455dcbafbd1 Mon Sep 17 00:00:00 2001 From: Alex Coats Date: Wed, 7 Feb 2024 15:27:30 -0500 Subject: [PATCH 02/13] better impl --- .../fail/invalid_verify_with_field_type.rs | 4 +- .../fail/invalid_verify_with_struct_type.rs | 4 +- .../tests/pass/verify_with_field.rs | 8 +--- .../tests/pass/verify_with_field_visitor.rs | 4 +- .../tests/pass/verify_with_struct.rs | 4 +- .../tests/pass/verify_with_struct_visitor.rs | 4 +- packable/packable-derive/src/enum_info.rs | 11 +++-- packable/packable-derive/src/fragments.rs | 45 ++++++++++++++++--- packable/packable-derive/src/struct_info.rs | 30 +++++++++++-- packable/packable-derive/src/trait_impl.rs | 6 ++- .../src/unpack_visitor_info.rs | 6 ++- packable/packable/src/packable/bounded.rs | 8 ++-- packable/packable/src/packable/box.rs | 2 +- packable/packable/src/packable/map.rs | 8 ++-- packable/packable/src/packable/mod.rs | 44 +++++++++++++----- packable/packable/src/packable/option.rs | 2 +- .../packable/src/packable/prefix/btreeset.rs | 2 +- packable/packable/src/packable/prefix/map.rs | 8 ++-- packable/packable/src/packable/prefix/vec.rs | 2 +- packable/packable/src/packable/set.rs | 2 +- packable/packable/src/packable/tuple.rs | 2 +- packable/packable/src/packable/vec.rs | 2 +- packable/packable/tests/bool.rs | 2 +- packable/packable/tests/bounded.rs | 2 +- packable/packable/tests/boxed_slice_prefix.rs | 2 +- packable/packable/tests/btreemap.rs | 4 +- packable/packable/tests/btreemap_prefix.rs | 10 ++--- packable/packable/tests/btreeset.rs | 4 +- packable/packable/tests/btreeset_prefix.rs | 10 ++--- packable/packable/tests/common/mod.rs | 6 +-- packable/packable/tests/counter.rs | 2 +- packable/packable/tests/map.rs | 2 +- packable/packable/tests/map_prefix.rs | 6 +-- packable/packable/tests/string_prefix.rs | 2 +- packable/packable/tests/vec_prefix.rs | 2 +- 35 files changed, 171 insertions(+), 91 deletions(-) diff --git a/packable/packable-derive-test/tests/fail/invalid_verify_with_field_type.rs b/packable/packable-derive-test/tests/fail/invalid_verify_with_field_type.rs index df824f6..120bc88 100644 --- a/packable/packable-derive-test/tests/fail/invalid_verify_with_field_type.rs +++ b/packable/packable-derive-test/tests/fail/invalid_verify_with_field_type.rs @@ -21,8 +21,8 @@ impl From for PickyError { } } -fn verify_value(value: &u64, visitor: Option<&()>) -> Result<(), PickyError> { - if visitor.is_none() || value == 42 { +fn verify_value(value: &u64) -> Result<(), PickyError> { + if value == 42 { Ok(()) } else { Err(PickyError(value as u8)) diff --git a/packable/packable-derive-test/tests/fail/invalid_verify_with_struct_type.rs b/packable/packable-derive-test/tests/fail/invalid_verify_with_struct_type.rs index 47e2c9b..b988d8b 100644 --- a/packable/packable-derive-test/tests/fail/invalid_verify_with_struct_type.rs +++ b/packable/packable-derive-test/tests/fail/invalid_verify_with_struct_type.rs @@ -21,8 +21,8 @@ impl From for PickyError { } } -fn verify(value: &u64, visitor: Option<&()>) -> Result<(), PickyError> { - if visitor.is_none() || value == 42 { +fn verify(value: &u64) -> Result<(), PickyError> { + if value == 42 { Ok(()) } else { Err(PickyError(value as u8)) diff --git a/packable/packable-derive-test/tests/pass/verify_with_field.rs b/packable/packable-derive-test/tests/pass/verify_with_field.rs index 6d06b91..f035b0c 100644 --- a/packable/packable-derive-test/tests/pass/verify_with_field.rs +++ b/packable/packable-derive-test/tests/pass/verify_with_field.rs @@ -21,12 +21,8 @@ impl From for PickyError { } } -fn verify_value(value: &u8, visitor: Option<&()>) -> Result<(), PickyError> { - if visitor.is_none() || value == 42 { - Ok(()) - } else { - Err(PickyError(value)) - } +fn verify_value(value: &u8) -> Result<(), PickyError> { + if value == 42 { Ok(()) } else { Err(PickyError(value)) } } #[derive(Packable)] diff --git a/packable/packable-derive-test/tests/pass/verify_with_field_visitor.rs b/packable/packable-derive-test/tests/pass/verify_with_field_visitor.rs index bb1fb79..a06b46b 100644 --- a/packable/packable-derive-test/tests/pass/verify_with_field_visitor.rs +++ b/packable/packable-derive-test/tests/pass/verify_with_field_visitor.rs @@ -21,8 +21,8 @@ impl From for PickyError { } } -fn verify(value: &u64, visitor: Option<&()>) -> Result<(), PickyError> { - if visitor.is_none() || value == 42 { +fn verify(value: &u64) -> Result<(), PickyError> { + if value == 42 { Ok(()) } else { Err(PickyError(value as u8)) diff --git a/packable/packable-derive-test/tests/pass/verify_with_struct.rs b/packable/packable-derive-test/tests/pass/verify_with_struct.rs index f0ef8eb..acbf5cd 100644 --- a/packable/packable-derive-test/tests/pass/verify_with_struct.rs +++ b/packable/packable-derive-test/tests/pass/verify_with_struct.rs @@ -21,8 +21,8 @@ impl From for PickyError { } } -fn verify(value: &Picky, visitor: Option<&()>) -> Result<(), PickyError> { - if visitor.is_none() || value.0 == 42 { +fn verify(value: &Picky) -> Result<(), PickyError> { + if value.0 == 42 { Ok(()) } else { Err(PickyError(value.0)) diff --git a/packable/packable-derive-test/tests/pass/verify_with_struct_visitor.rs b/packable/packable-derive-test/tests/pass/verify_with_struct_visitor.rs index daf9c6e..83a454f 100644 --- a/packable/packable-derive-test/tests/pass/verify_with_struct_visitor.rs +++ b/packable/packable-derive-test/tests/pass/verify_with_struct_visitor.rs @@ -21,8 +21,8 @@ impl From for PickyError { } } -fn verify(value: &Picky, visitor: Option<&()>) -> Result<(), PickyError> { - if visitor.is_none() || value.0 == 42 { +fn verify(value: &Picky) -> Result<(), PickyError> { + if value.0 == 42 { Ok(()) } else { Err(PickyError(value.0)) diff --git a/packable/packable-derive/src/enum_info.rs b/packable/packable-derive/src/enum_info.rs index e9643e9..6966a05 100644 --- a/packable/packable-derive/src/enum_info.rs +++ b/packable/packable-derive/src/enum_info.rs @@ -34,17 +34,20 @@ impl EnumInfo { )?; let unpack_visitor = UnpackVisitorInfo::new(filtered_attrs, || { - let unpack_visitor = match data + let (unpack_visitor, explicit) = match data .variants .iter() .next() .and_then(|variant| variant.fields.iter().next()) { - Some(Field { ty, .. }) => parse_quote!(<#ty as #crate_name::Packable>::UnpackVisitor), - None => parse_quote!(()), + Some(Field { ty, .. }) => (parse_quote!(<#ty as #crate_name::Packable>::UnpackVisitor), true), + None => (parse_quote!(()), false), }; - Ok(UnpackVisitorInfo { unpack_visitor }) + Ok(UnpackVisitorInfo { + unpack_visitor, + explicit, + }) })?; let variants_info = data diff --git a/packable/packable-derive/src/fragments.rs b/packable/packable-derive/src/fragments.rs index e53b3a7..2e73914 100644 --- a/packable/packable-derive/src/fragments.rs +++ b/packable/packable-derive/src/fragments.rs @@ -5,7 +5,7 @@ use proc_macro2::TokenStream; use quote::quote; use syn::{Ident, Path}; -use crate::record_info::RecordInfo; +use crate::{record_info::RecordInfo, unpack_visitor_info::UnpackVisitorInfo}; pub(crate) struct Fragments { // The pattern used to destructure the record. @@ -17,7 +17,12 @@ pub(crate) struct Fragments { } impl Fragments { - pub(crate) fn new(info: RecordInfo, verify_with: Option, crate_name: &Ident) -> Self { + pub(crate) fn new( + info: RecordInfo, + verify_with: Option, + unpack_visitor_info: &UnpackVisitorInfo, + crate_name: &Ident, + ) -> Self { let RecordInfo { path, fields_unpack_error_with, @@ -27,14 +32,40 @@ impl Fragments { fields_type, } = info; - let fields_verification = fields_verify_with.into_iter().zip(fields_ident.iter()).map(|(verify_with, field_ident)| match verify_with { - Some(verify_with) => quote!(#verify_with(&#field_ident, visitor).map_err(#crate_name::error::UnpackError::from_packable)?;), - None => quote!(), - }); + let fields_verification = fields_verify_with.into_iter().zip(fields_ident.iter()).map( + |(verify_with, field_ident)| match verify_with { + Some(verify_with) => if unpack_visitor_info.explicit { + quote! { + if let Some(visitor) = visitor { + #verify_with(&#field_ident, visitor).map_err(#crate_name::error::UnpackError::from_packable)?; + } + } + } else { + quote! { + if visitor.is_some() { + #verify_with(&#field_ident).map_err(#crate_name::error::UnpackError::from_packable)?; + } + } + }, + None => quote!(), + }, + ); let verify_with = match verify_with { Some(verify_with) => { - quote!(#verify_with(&unpacked, visitor).map_err(#crate_name::error::UnpackError::from_packable)?;) + if unpack_visitor_info.explicit { + quote! { + if let Some(visitor) = visitor { + #verify_with(&unpacked, visitor).map_err(#crate_name::error::UnpackError::from_packable)?; + } + } + } else { + quote! { + if visitor.is_some() { + #verify_with(&unpacked).map_err(#crate_name::error::UnpackError::from_packable)?; + } + } + } } None => quote!(), }; diff --git a/packable/packable-derive/src/struct_info.rs b/packable/packable-derive/src/struct_info.rs index d194cda..0775b09 100644 --- a/packable/packable-derive/src/struct_info.rs +++ b/packable/packable-derive/src/struct_info.rs @@ -42,12 +42,34 @@ impl StructInfo { } let unpack_visitor = UnpackVisitorInfo::new(filtered_attrs, || { - let unpack_visitor = match fields.iter().next() { - Some(Field { ty, .. }) => parse_quote!(<#ty as #crate_name::Packable>::UnpackVisitor), - None => parse_quote!(()), + let (unpack_visitor, explicit) = match fields.iter().next() { + Some(Field { attrs, ty, .. }) => { + let mut explicit = false; + + for attr in filter_attrs(attrs) { + explicit = attr + .parse_args_with(|stream: ParseStream| { + let opt = parse_kv::("unpack_visitor", stream)?; + if opt.is_none() { + skip_stream(stream)?; + } + Ok(opt) + })? + .is_some(); + if explicit { + break; + } + } + + (parse_quote!(<#ty as #crate_name::Packable>::UnpackVisitor), explicit) + } + None => (parse_quote!(()), false), }; - Ok(UnpackVisitorInfo { unpack_visitor }) + Ok(UnpackVisitorInfo { + unpack_visitor, + explicit, + }) })?; let inner = RecordInfo::new(path, fields, &unpack_error.with)?; diff --git a/packable/packable-derive/src/trait_impl.rs b/packable/packable-derive/src/trait_impl.rs index a5c1687..28b3866 100644 --- a/packable/packable-derive/src/trait_impl.rs +++ b/packable/packable-derive/src/trait_impl.rs @@ -29,7 +29,8 @@ impl TraitImpl { let unpack_error = info.unpack_error.unpack_error.clone().into_token_stream(); let unpack_visitor = info.unpack_visitor.unpack_visitor.clone().into_token_stream(); - let Fragments { pattern, pack, unpack } = Fragments::new(info.inner, info.verify_with, &crate_name); + let Fragments { pattern, pack, unpack } = + Fragments::new(info.inner, info.verify_with, &info.unpack_visitor, &crate_name); Ok(Self { ident: input.ident, @@ -65,7 +66,8 @@ impl TraitImpl { for (index, VariantInfo { tag, inner }) in info.variants_info.into_iter().enumerate() { let variant_ident = inner.path.segments.last().unwrap().clone(); - let Fragments { pattern, pack, unpack } = Fragments::new(inner, None, &crate_name); + let Fragments { pattern, pack, unpack } = + Fragments::new(inner, None, &info.unpack_visitor, &crate_name); // @pvdrz: The span here is very important, otherwise the compiler won't detect // unreachable patterns in the generated code for some reason. I think this is related diff --git a/packable/packable-derive/src/unpack_visitor_info.rs b/packable/packable-derive/src/unpack_visitor_info.rs index e12e2ed..15c29ea 100644 --- a/packable/packable-derive/src/unpack_visitor_info.rs +++ b/packable/packable-derive/src/unpack_visitor_info.rs @@ -10,6 +10,7 @@ use crate::parse::{parse_kv, skip_stream}; pub(crate) struct UnpackVisitorInfo { pub(crate) unpack_visitor: syn::Type, + pub(crate) explicit: bool, } struct Type(syn::Type); @@ -34,7 +35,10 @@ impl UnpackVisitorInfo { let opt_info = attr.parse_args_with( |stream: ParseStream| match parse_kv::("unpack_visitor", stream)? { - Some(Type(unpack_visitor)) => Ok(Some(Self { unpack_visitor })), + Some(Type(unpack_visitor)) => Ok(Some(Self { + unpack_visitor, + explicit: true, + })), None => { skip_stream(stream)?; Ok(None) diff --git a/packable/packable/src/packable/bounded.rs b/packable/packable/src/packable/bounded.rs index 95e7206..a2356e2 100644 --- a/packable/packable/src/packable/bounded.rs +++ b/packable/packable/src/packable/bounded.rs @@ -41,8 +41,8 @@ macro_rules! bounded { self.0 } - fn verify(value: &$ty, visitor: Option<&()>) -> Result<(), $invalid_error> { - if visitor.is_some() && !(MIN..=MAX).contains(value) { + fn verify(value: &$ty) -> Result<(), $invalid_error> { + if !(MIN..=MAX).contains(value) { Err($invalid_error(*value)) } else { Ok(()) @@ -67,7 +67,7 @@ macro_rules! bounded { type Error = $invalid_error; fn try_from(value: $ty) -> Result { - // Self::verify(&value, Some(&()))?; + Self::verify(&value)?; Ok(Self(value)) } } @@ -113,7 +113,7 @@ macro_rules! bounded { } #[doc = concat!("Error encountered when attempting to convert a [`usize`] into a [`", - stringify!($wrapper),"`].")] + stringify!($wrapper),"`].")] #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum $try_error { #[doc = concat!("The `usize` could be converted into a [`", stringify!($ty),"`] but it is not within the diff --git a/packable/packable/src/packable/box.rs b/packable/packable/src/packable/box.rs index 25e7beb..ff64585 100644 --- a/packable/packable/src/packable/box.rs +++ b/packable/packable/src/packable/box.rs @@ -60,7 +60,7 @@ impl Packable for Box<[T]> { ) -> Result> { use crate::error::UnpackErrorExt; - let len = u64::unpack(unpacker, None) + let len = u64::unpack_inner(unpacker, visitor) .coerce()? .try_into() .map_err(|err| UnpackError::Packable(Self::UnpackError::Prefix(err)))?; diff --git a/packable/packable/src/packable/map.rs b/packable/packable/src/packable/map.rs index 1a6ec7b..26bcafa 100644 --- a/packable/packable/src/packable/map.rs +++ b/packable/packable/src/packable/map.rs @@ -143,7 +143,7 @@ where ) -> Result> { use crate::error::UnpackErrorExt; - let len = u64::unpack(unpacker, None) + let len = u64::unpack_inner(unpacker, visitor) .coerce()? .try_into() .map_err(|err| UnpackError::Packable(UnpackMapError::Prefix(err)))?; @@ -151,7 +151,7 @@ where let mut map = HashMap::::with_capacity(len); for _ in 0..len { - let key = K::unpack(unpacker, visitor.map(Borrow::borrow)) + let key = K::unpack_inner(unpacker, visitor) .map_packable_err(UnpackMapError::Key) .map_packable_err(Self::UnpackError::from)?; @@ -198,7 +198,7 @@ where ) -> Result> { use crate::error::UnpackErrorExt; - let len = u64::unpack(unpacker, None) + let len = u64::unpack_inner(unpacker, visitor) .coerce()? .try_into() .map_err(|err| UnpackError::Packable(UnpackMapError::Prefix(err).into()))?; @@ -206,7 +206,7 @@ where let mut map = BTreeMap::::new(); for _ in 0..len { - let key = K::unpack(unpacker, visitor.map(Borrow::borrow)) + let key = K::unpack_inner(unpacker, visitor) .map_packable_err(UnpackMapError::Key) .map_packable_err(Self::UnpackError::from)?; diff --git a/packable/packable/src/packable/mod.rs b/packable/packable/src/packable/mod.rs index a5b8c4d..5fb4cc7 100644 --- a/packable/packable/src/packable/mod.rs +++ b/packable/packable/src/packable/mod.rs @@ -84,9 +84,9 @@ use crate::{ /// unpacker: &mut U, /// visitor: Option<&Self::UnpackVisitor>, /// ) -> Result> { -/// match u8::unpack(unpacker, visitor).coerce()? { +/// match u8::unpack_inner(unpacker, visitor).coerce()? { /// 0u8 => Ok(Self::Nothing), -/// 1u8 => Ok(Self::Just(i32::unpack(unpacker, visitor).coerce()?)), +/// 1u8 => Ok(Self::Just(i32::unpack_inner(unpacker, visitor).coerce()?)), /// tag => Err(UnpackError::Packable(UnknownTagError(tag))), /// } /// } @@ -172,10 +172,11 @@ use crate::{ /// `#[packable(verify_with = ...)]` attribute which must receive a valid Rust path refering to a /// function with the signature /// ```ignore -/// fn(field: &F, visitor: Option<&P::UnpackVisitor>) -> Result<(), P::UnpackError> +/// fn(field: &F, visitor: &P::UnpackVisitor) -> Result<(), P::UnpackError> /// ``` /// where `F` is the type of the field being verified, `P` is the type of the `struct` or `enum`. -/// This verification function will be run immediately after unpacking the field. +/// This verification function will be run immediately after unpacking the field. The `visitor` +/// param can be excluded if it is not needed for verification. pub trait Packable: Sized + 'static { /// The error type that can be returned if some semantic error occurs while unpacking. /// @@ -188,12 +189,33 @@ pub trait Packable: Sized + 'static { /// Packs this value into the given [`Packer`]. fn pack(&self, packer: &mut P) -> Result<(), P::Error>; - /// Unpacks this value from the given [`Unpacker`]. The optional visitor can be used to skip additional + /// Unpacks this value from the given [`Unpacker`]. The optional visitor can be used to make additional /// syntactic checks. fn unpack( unpacker: &mut U, visitor: Option<&Self::UnpackVisitor>, ) -> Result>; + + /// Unpacks this value from the given [`Unpacker`] with a visitor for validation. + fn unpack_verified( + unpacker: &mut U, + visitor: &Self::UnpackVisitor, + ) -> Result> { + Self::unpack(unpacker, Some(visitor)) + } + + /// Unpacks this value from the given [`Unpacker`] without validation. + fn unpack_unverified(unpacker: &mut U) -> Result> { + Self::unpack(unpacker, None) + } + + /// Unpacks an inner value whose visitor type can be borrowed from the outer visitor. + fn unpack_inner, U: Unpacker>( + unpacker: &mut U, + visitor: Option<&V>, + ) -> Result> { + Self::unpack(unpacker, visitor.map(Borrow::borrow)) + } } /// Extension trait for types that implement [`Packable`]. @@ -206,13 +228,13 @@ pub trait PackableExt: Packable { fn pack_to_vec(&self) -> Vec; /// Unpacks this value from a sequence of bytes doing syntactical checks. - fn unpack_verified>( + fn unpack_bytes_verified>( bytes: T, visitor: &Self::UnpackVisitor, ) -> Result::UnpackError, UnexpectedEOF>>; /// Unpacks this value from a sequence of bytes without doing syntactical checks. - fn unpack_unverified>( + fn unpack_bytes_unverified>( bytes: T, ) -> Result::UnpackError, UnexpectedEOF>>; } @@ -240,18 +262,18 @@ impl PackableExt for P { /// Unpacks this value from a type that implements [`AsRef<[u8]>`]. #[inline] - fn unpack_verified>( + fn unpack_bytes_verified>( bytes: T, visitor: &P::UnpackVisitor, ) -> Result::UnpackError, UnexpectedEOF>> { - Self::unpack(&mut SliceUnpacker::new(bytes.as_ref()), Some(visitor)) + Self::unpack_verified(&mut SliceUnpacker::new(bytes.as_ref()), visitor) } /// Unpacks this value from a type that implements [`AsRef<[u8]>`] skipping some syntatical checks. #[inline] - fn unpack_unverified>( + fn unpack_bytes_unverified>( bytes: T, ) -> Result::UnpackError, UnexpectedEOF>> { - Self::unpack(&mut SliceUnpacker::new(bytes.as_ref()), None) + Self::unpack_unverified(&mut SliceUnpacker::new(bytes.as_ref())) } } diff --git a/packable/packable/src/packable/option.rs b/packable/packable/src/packable/option.rs index d4c239d..9a30ced 100644 --- a/packable/packable/src/packable/option.rs +++ b/packable/packable/src/packable/option.rs @@ -58,7 +58,7 @@ impl Packable for Option { unpacker: &mut U, visitor: Option<&Self::UnpackVisitor>, ) -> Result> { - match u8::unpack(unpacker, None).coerce()? { + match u8::unpack_inner(unpacker, visitor).coerce()? { 0 => Ok(None), 1 => Ok(Some( T::unpack(unpacker, visitor).map_packable_err(UnpackOptionError::Inner)?, diff --git a/packable/packable/src/packable/prefix/btreeset.rs b/packable/packable/src/packable/prefix/btreeset.rs index 25e29a6..0275e01 100644 --- a/packable/packable/src/packable/prefix/btreeset.rs +++ b/packable/packable/src/packable/prefix/btreeset.rs @@ -113,7 +113,7 @@ where use crate::error::UnpackErrorExt; // The length of any dynamically-sized sequence must be prefixed. - let len = B::unpack(unpacker, None) + let len = B::unpack_inner(unpacker, visitor) .map_packable_err(UnpackSetError::Prefix) .map_packable_err(Self::UnpackError::from)? .into(); diff --git a/packable/packable/src/packable/prefix/map.rs b/packable/packable/src/packable/prefix/map.rs index 7f6f20e..c8c51f5 100644 --- a/packable/packable/src/packable/prefix/map.rs +++ b/packable/packable/src/packable/prefix/map.rs @@ -118,7 +118,7 @@ where use crate::error::UnpackErrorExt; // The length of any dynamically-sized sequence must be prefixed. - let len = B::unpack(unpacker, None) + let len = B::unpack_inner(unpacker, visitor) .map_packable_err(UnpackMapError::Prefix) .map_packable_err(Self::UnpackError::from)? .into(); @@ -126,7 +126,7 @@ where let mut map = HashMap::::new(); for _ in B::Bounds::default()..len { - let key = K::unpack(unpacker, visitor.map(Borrow::borrow)) + let key = K::unpack_inner(unpacker, visitor) .map_packable_err(UnpackMapError::Key) .map_packable_err(Self::UnpackError::from)?; @@ -243,7 +243,7 @@ where use crate::error::UnpackErrorExt; // The length of any dynamically-sized sequence must be prefixed. - let len = B::unpack(unpacker, None) + let len = B::unpack_inner(unpacker, visitor) .map_packable_err(UnpackMapError::Prefix) .map_packable_err(Self::UnpackError::from)? .into(); @@ -251,7 +251,7 @@ where let mut map = BTreeMap::::new(); for _ in B::Bounds::default()..len { - let key = K::unpack(unpacker, visitor.map(Borrow::borrow)) + let key = K::unpack_inner(unpacker, visitor) .map_packable_err(UnpackMapError::Key) .map_packable_err(Self::UnpackError::from)?; diff --git a/packable/packable/src/packable/prefix/vec.rs b/packable/packable/src/packable/prefix/vec.rs index 28492dc..7377625 100644 --- a/packable/packable/src/packable/prefix/vec.rs +++ b/packable/packable/src/packable/prefix/vec.rs @@ -115,7 +115,7 @@ where visitor: Option<&Self::UnpackVisitor>, ) -> Result> { // The length of any dynamically-sized sequence must be prefixed. - let len = B::unpack(unpacker, None) + let len = B::unpack_inner(unpacker, visitor) .map_packable_err(UnpackPrefixError::Prefix)? .into(); diff --git a/packable/packable/src/packable/set.rs b/packable/packable/src/packable/set.rs index 91f4cd2..acd48c0 100644 --- a/packable/packable/src/packable/set.rs +++ b/packable/packable/src/packable/set.rs @@ -128,7 +128,7 @@ mod btreeset { ) -> Result> { use crate::error::UnpackErrorExt; - let len = u64::unpack(unpacker, None) + let len = u64::unpack_inner(unpacker, visitor) .coerce()? .try_into() .map_err(|err| UnpackError::Packable(UnpackSetError::Prefix(err).into()))?; diff --git a/packable/packable/src/packable/tuple.rs b/packable/packable/src/packable/tuple.rs index 4e2efb0..1b2bb3b 100644 --- a/packable/packable/src/packable/tuple.rs +++ b/packable/packable/src/packable/tuple.rs @@ -34,7 +34,7 @@ macro_rules! tuple_impls { ) -> Result> { Ok(( <$FirstT>::unpack(unpacker, visitor)?, - $( (<$T>::unpack(unpacker, visitor.map(core::borrow::Borrow::borrow)).map_packable_err(Into::into))?,)* + $( (<$T>::unpack_inner(unpacker, visitor).map_packable_err(Into::into))?,)* )) } } diff --git a/packable/packable/src/packable/vec.rs b/packable/packable/src/packable/vec.rs index 8f6b57f..522d11f 100644 --- a/packable/packable/src/packable/vec.rs +++ b/packable/packable/src/packable/vec.rs @@ -44,7 +44,7 @@ where unpacker: &mut U, visitor: Option<&Self::UnpackVisitor>, ) -> Result> { - let len = u64::unpack(unpacker, None) + let len = u64::unpack_inner(unpacker, visitor) .coerce()? .try_into() .map_err(|err| UnpackError::Packable(UnpackPrefixError::Prefix(err)))?; diff --git a/packable/packable/tests/bool.rs b/packable/packable/tests/bool.rs index 429af5a..5d87ee2 100644 --- a/packable/packable/tests/bool.rs +++ b/packable/packable/tests/bool.rs @@ -16,7 +16,7 @@ fn packable_bool_packed_non_zero_bytes_are_truthy() { let mut packer = Vec::default(); 42u8.pack(&mut packer).unwrap(); - let is_true = bool::unpack_verified(packer.as_slice(), &()).unwrap(); + let is_true = bool::unpack_bytes_verified(packer.as_slice(), &()).unwrap(); assert!(is_true); } diff --git a/packable/packable/tests/bounded.rs b/packable/packable/tests/bounded.rs index f61e099..e40ecc9 100644 --- a/packable/packable/tests/bounded.rs +++ b/packable/packable/tests/bounded.rs @@ -51,7 +51,7 @@ macro_rules! impl_packable_test_for_bounded_integer { #[test] fn $packable_invalid_name() { let bytes = vec![0u8; core::mem::size_of::<$wrapped>()]; - let unpacked = <$wrapper>::unpack_verified(&bytes, &()); + let unpacked = <$wrapper>::unpack_bytes_verified(&bytes, &()); assert!(matches!(unpacked, Err(UnpackError::Packable($error(0))))) } diff --git a/packable/packable/tests/boxed_slice_prefix.rs b/packable/packable/tests/boxed_slice_prefix.rs index d56e120..20e0bb6 100644 --- a/packable/packable/tests/boxed_slice_prefix.rs +++ b/packable/packable/tests/boxed_slice_prefix.rs @@ -73,7 +73,7 @@ macro_rules! impl_packable_test_for_bounded_boxed_slice_prefix { let mut bytes = vec![0u8; LEN + 1].into_boxed_slice(); bytes[0] = LEN as u8; - let prefixed = BoxedSlicePrefix::>::unpack_verified(bytes, &()); + let prefixed = BoxedSlicePrefix::>::unpack_bytes_verified(bytes, &()); const LEN_AS_TY: $ty = LEN as $ty; diff --git a/packable/packable/tests/btreemap.rs b/packable/packable/tests/btreemap.rs index 7b6ff2a..11a4171 100644 --- a/packable/packable/tests/btreemap.rs +++ b/packable/packable/tests/btreemap.rs @@ -34,7 +34,7 @@ fn invalid_duplicate() { .chain(bytes.into_iter().flat_map(|(k, v)| [k, v])), ); - let prefixed = BTreeMap::::unpack_verified(bytes, &()); + let prefixed = BTreeMap::::unpack_bytes_verified(bytes, &()); assert!(matches!( prefixed, @@ -55,7 +55,7 @@ fn invalid_unordered() { .chain(bytes.into_iter().flat_map(|(k, v)| [k, v])), ); - let prefixed = BTreeMap::::unpack_verified(bytes, &()); + let prefixed = BTreeMap::::unpack_bytes_verified(bytes, &()); assert!(matches!( prefixed, diff --git a/packable/packable/tests/btreemap_prefix.rs b/packable/packable/tests/btreemap_prefix.rs index d4b5b6e..02ad25e 100644 --- a/packable/packable/tests/btreemap_prefix.rs +++ b/packable/packable/tests/btreemap_prefix.rs @@ -63,7 +63,7 @@ macro_rules! impl_packable_test_for_btreemap_prefix { let bytes = Vec::from_iter(LEN_AS_TY.to_le_bytes().into_iter().chain(bytes)); - let prefixed = BTreeMapPrefix::::unpack_verified(bytes, &()); + let prefixed = BTreeMapPrefix::::unpack_bytes_verified(bytes, &()); assert!(matches!( prefixed, @@ -85,7 +85,7 @@ macro_rules! impl_packable_test_for_btreemap_prefix { let bytes = Vec::from_iter(LEN_AS_TY.to_le_bytes().into_iter().chain(bytes)); - let prefixed = BTreeMapPrefix::::unpack_verified(bytes, &()); + let prefixed = BTreeMapPrefix::::unpack_bytes_verified(bytes, &()); assert!(matches!( prefixed, @@ -128,7 +128,7 @@ macro_rules! impl_packable_test_for_bounded_btreemap_prefix { let bytes = Vec::from_iter(LEN_AS_TY.to_le_bytes().into_iter().chain(core::iter::repeat(0).take(2 * (LEN + 1)))); - let prefixed = BTreeMapPrefix::>::unpack_verified(bytes, &()); + let prefixed = BTreeMapPrefix::>::unpack_bytes_verified(bytes, &()); assert!(matches!( prefixed, @@ -149,7 +149,7 @@ macro_rules! impl_packable_test_for_bounded_btreemap_prefix { let bytes = Vec::from_iter(LEN_AS_TY.to_le_bytes().into_iter().chain(bytes)); - let prefixed = BTreeMapPrefix::>::unpack_verified(bytes, &()); + let prefixed = BTreeMapPrefix::>::unpack_bytes_verified(bytes, &()); assert!(matches!( prefixed, @@ -171,7 +171,7 @@ macro_rules! impl_packable_test_for_bounded_btreemap_prefix { let bytes = Vec::from_iter(LEN_AS_TY.to_le_bytes().into_iter().chain(bytes)); - let prefixed = BTreeMapPrefix::>::unpack_verified(bytes, &()); + let prefixed = BTreeMapPrefix::>::unpack_bytes_verified(bytes, &()); assert!(matches!( prefixed, diff --git a/packable/packable/tests/btreeset.rs b/packable/packable/tests/btreeset.rs index 6ea1534..10626bc 100644 --- a/packable/packable/tests/btreeset.rs +++ b/packable/packable/tests/btreeset.rs @@ -26,7 +26,7 @@ fn invalid_duplicate() { let bytes = [1, 2, 3, 3, 4]; let bytes = Vec::from_iter(bytes.len().to_le_bytes().into_iter().chain(bytes)); - let prefixed = BTreeSet::::unpack_verified(bytes, &()); + let prefixed = BTreeSet::::unpack_bytes_verified(bytes, &()); println!("{prefixed:?}"); @@ -43,7 +43,7 @@ fn invalid_unordered() { let bytes = [1, 2, 4, 3]; let bytes = Vec::from_iter(bytes.len().to_le_bytes().into_iter().chain(bytes)); - let prefixed = BTreeSet::::unpack_verified(bytes, &()); + let prefixed = BTreeSet::::unpack_bytes_verified(bytes, &()); assert!(matches!( prefixed, diff --git a/packable/packable/tests/btreeset_prefix.rs b/packable/packable/tests/btreeset_prefix.rs index 9b112c7..635675c 100644 --- a/packable/packable/tests/btreeset_prefix.rs +++ b/packable/packable/tests/btreeset_prefix.rs @@ -63,7 +63,7 @@ macro_rules! impl_packable_test_for_btreeset_prefix { let bytes = Vec::from_iter(LEN_AS_TY.to_le_bytes().into_iter().chain(bytes)); - let prefixed = BTreeSetPrefix::::unpack_verified(bytes, &()); + let prefixed = BTreeSetPrefix::::unpack_bytes_verified(bytes, &()); assert!(matches!( prefixed, @@ -83,7 +83,7 @@ macro_rules! impl_packable_test_for_btreeset_prefix { let bytes = Vec::from_iter(LEN_AS_TY.to_le_bytes().into_iter().chain(bytes)); - let prefixed = BTreeSetPrefix::::unpack_verified(bytes, &()); + let prefixed = BTreeSetPrefix::::unpack_bytes_verified(bytes, &()); assert!(matches!( prefixed, @@ -126,7 +126,7 @@ macro_rules! impl_packable_test_for_bounded_btreeset_prefix { let bytes = Vec::from_iter(LEN_AS_TY.to_le_bytes().into_iter().chain(core::iter::repeat(0).take(LEN + 1))); - let prefixed = BTreeSetPrefix::>::unpack_verified(bytes, &()); + let prefixed = BTreeSetPrefix::>::unpack_bytes_verified(bytes, &()); assert!(matches!( prefixed, @@ -147,7 +147,7 @@ macro_rules! impl_packable_test_for_bounded_btreeset_prefix { let bytes = Vec::from_iter(LEN_AS_TY.to_le_bytes().into_iter().chain(bytes)); - let prefixed = BTreeSetPrefix::>::unpack_verified(bytes, &()); + let prefixed = BTreeSetPrefix::>::unpack_bytes_verified(bytes, &()); assert!(matches!( prefixed, @@ -167,7 +167,7 @@ macro_rules! impl_packable_test_for_bounded_btreeset_prefix { let bytes = Vec::from_iter(LEN_AS_TY.to_le_bytes().into_iter().chain(bytes)); - let prefixed = BTreeSetPrefix::>::unpack_verified(bytes, &()); + let prefixed = BTreeSetPrefix::>::unpack_bytes_verified(bytes, &()); assert!(matches!( prefixed, diff --git a/packable/packable/tests/common/mod.rs b/packable/packable/tests/common/mod.rs index 9cce1aa..9da3797 100644 --- a/packable/packable/tests/common/mod.rs +++ b/packable/packable/tests/common/mod.rs @@ -19,7 +19,7 @@ where let mut packer = SlicePacker::new(&mut vec); packable.pack(&mut packer).unwrap(); - let unpacked = P::unpack_verified(&vec, &()).unwrap(); + let unpacked = P::unpack_bytes_verified(&vec, &()).unwrap(); assert_eq!(packable, &unpacked); @@ -35,7 +35,7 @@ where P::UnpackError: Debug, { let vec = packable.pack_to_vec(); - let unpacked = P::unpack_verified(&vec, &()).unwrap(); + let unpacked = P::unpack_bytes_verified(&vec, &()).unwrap(); assert_eq!(packable, &unpacked); assert_eq!(packable.packed_len(), vec.len()); @@ -52,7 +52,7 @@ where let mut vec = Vec::new(); packable.pack(&mut vec).unwrap(); - let unpacked = P::unpack_verified(vec.as_slice(), &()).unwrap(); + let unpacked = P::unpack_bytes_verified(vec.as_slice(), &()).unwrap(); assert_eq!(packable, &unpacked); // Tests for `Read` and `Write` diff --git a/packable/packable/tests/counter.rs b/packable/packable/tests/counter.rs index a6d325d..829bc4a 100644 --- a/packable/packable/tests/counter.rs +++ b/packable/packable/tests/counter.rs @@ -19,7 +19,7 @@ fn option_counter() { let packer = packer.into_inner(); let mut unpacker = CounterUnpacker::new(SliceUnpacker::new(packer.as_slice())); - let unpacked_value = Option::::unpack(&mut unpacker, None).unwrap(); + let unpacked_value = Option::::unpack_verified(&mut unpacker, &()).unwrap(); assert_eq!(unpacked_value.packed_len(), unpacker.counter()); assert_eq!(unpacker.counter(), unpacker.read_bytes().unwrap()); assert_eq!(value, unpacked_value); diff --git a/packable/packable/tests/map.rs b/packable/packable/tests/map.rs index 7dfee4e..bae5c4c 100644 --- a/packable/packable/tests/map.rs +++ b/packable/packable/tests/map.rs @@ -29,7 +29,7 @@ fn invalid_duplicate() { .chain(bytes.into_iter().flat_map(|(k, v)| [k, v])), ); - let prefixed = HashMap::::unpack_verified(bytes, &()); + let prefixed = HashMap::::unpack_bytes_verified(bytes, &()); assert!(matches!( prefixed, diff --git a/packable/packable/tests/map_prefix.rs b/packable/packable/tests/map_prefix.rs index 7737d0f..13df217 100644 --- a/packable/packable/tests/map_prefix.rs +++ b/packable/packable/tests/map_prefix.rs @@ -61,7 +61,7 @@ macro_rules! impl_packable_test_for_map_prefix { let bytes = Vec::from_iter(LEN_AS_TY.to_le_bytes().into_iter().chain(bytes)); - let prefixed = HashMapPrefix::::unpack_verified(bytes, &()); + let prefixed = HashMapPrefix::::unpack_bytes_verified(bytes, &()); assert!(matches!( prefixed, @@ -105,7 +105,7 @@ macro_rules! impl_packable_test_for_bounded_map_prefix { let bytes = Vec::from_iter(LEN_AS_TY.to_le_bytes().into_iter().chain(core::iter::repeat(0).take(2 * (LEN + 1)))); - let prefixed = HashMapPrefix::>::unpack_verified(bytes, &()); + let prefixed = HashMapPrefix::>::unpack_bytes_verified(bytes, &()); assert!(matches!( prefixed, @@ -126,7 +126,7 @@ macro_rules! impl_packable_test_for_bounded_map_prefix { let bytes = Vec::from_iter(LEN_AS_TY.to_le_bytes().into_iter().chain(bytes)); - let prefixed = HashMapPrefix::>::unpack_verified(bytes, &()); + let prefixed = HashMapPrefix::>::unpack_bytes_verified(bytes, &()); assert!(matches!( prefixed, diff --git a/packable/packable/tests/string_prefix.rs b/packable/packable/tests/string_prefix.rs index 4c380fc..0562929 100644 --- a/packable/packable/tests/string_prefix.rs +++ b/packable/packable/tests/string_prefix.rs @@ -68,7 +68,7 @@ macro_rules! impl_packable_test_for_bounded_string_prefix { let mut bytes = vec![0; LEN + 1]; bytes[0] = LEN as u8; - let prefixed = StringPrefix::<$bounded<$min, $max>>::unpack_verified(bytes, &()); + let prefixed = StringPrefix::<$bounded<$min, $max>>::unpack_bytes_verified(bytes, &()); const LEN_AS_TY: $ty = LEN as $ty; diff --git a/packable/packable/tests/vec_prefix.rs b/packable/packable/tests/vec_prefix.rs index b77b0c5..6e648da 100644 --- a/packable/packable/tests/vec_prefix.rs +++ b/packable/packable/tests/vec_prefix.rs @@ -68,7 +68,7 @@ macro_rules! impl_packable_test_for_bounded_vec_prefix { let mut bytes = vec![0u8; LEN + 1]; bytes[0] = LEN as u8; - let prefixed = VecPrefix::>::unpack_verified(bytes, &()); + let prefixed = VecPrefix::>::unpack_bytes_verified(bytes, &()); const LEN_AS_TY: $ty = LEN as $ty; From 4247779446fb54219483781834dcab63b42e78d1 Mon Sep 17 00:00:00 2001 From: Alex Coats Date: Thu, 8 Feb 2024 10:03:12 -0500 Subject: [PATCH 03/13] destructures --- .../tests/fail/invalid_verify_with_field_type.rs | 2 +- .../tests/fail/invalid_verify_with_struct_type.rs | 2 +- packable/packable-derive-test/tests/pass/verify_with_field.rs | 2 +- .../tests/pass/verify_with_field_visitor.rs | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/packable/packable-derive-test/tests/fail/invalid_verify_with_field_type.rs b/packable/packable-derive-test/tests/fail/invalid_verify_with_field_type.rs index 120bc88..5191544 100644 --- a/packable/packable-derive-test/tests/fail/invalid_verify_with_field_type.rs +++ b/packable/packable-derive-test/tests/fail/invalid_verify_with_field_type.rs @@ -21,7 +21,7 @@ impl From for PickyError { } } -fn verify_value(value: &u64) -> Result<(), PickyError> { +fn verify_value(&value: &u64) -> Result<(), PickyError> { if value == 42 { Ok(()) } else { diff --git a/packable/packable-derive-test/tests/fail/invalid_verify_with_struct_type.rs b/packable/packable-derive-test/tests/fail/invalid_verify_with_struct_type.rs index b988d8b..2410801 100644 --- a/packable/packable-derive-test/tests/fail/invalid_verify_with_struct_type.rs +++ b/packable/packable-derive-test/tests/fail/invalid_verify_with_struct_type.rs @@ -21,7 +21,7 @@ impl From for PickyError { } } -fn verify(value: &u64) -> Result<(), PickyError> { +fn verify(&value: &u64) -> Result<(), PickyError> { if value == 42 { Ok(()) } else { diff --git a/packable/packable-derive-test/tests/pass/verify_with_field.rs b/packable/packable-derive-test/tests/pass/verify_with_field.rs index f035b0c..fce4380 100644 --- a/packable/packable-derive-test/tests/pass/verify_with_field.rs +++ b/packable/packable-derive-test/tests/pass/verify_with_field.rs @@ -21,7 +21,7 @@ impl From for PickyError { } } -fn verify_value(value: &u8) -> Result<(), PickyError> { +fn verify_value(&value: &u8) -> Result<(), PickyError> { if value == 42 { Ok(()) } else { Err(PickyError(value)) } } diff --git a/packable/packable-derive-test/tests/pass/verify_with_field_visitor.rs b/packable/packable-derive-test/tests/pass/verify_with_field_visitor.rs index a06b46b..2d20ccd 100644 --- a/packable/packable-derive-test/tests/pass/verify_with_field_visitor.rs +++ b/packable/packable-derive-test/tests/pass/verify_with_field_visitor.rs @@ -21,7 +21,7 @@ impl From for PickyError { } } -fn verify(value: &u64) -> Result<(), PickyError> { +fn verify(&value: &u64) -> Result<(), PickyError> { if value == 42 { Ok(()) } else { From d746992727074dc7c5a879a4fafb197d1a56f5c0 Mon Sep 17 00:00:00 2001 From: Alex Coats Date: Thu, 8 Feb 2024 10:42:57 -0500 Subject: [PATCH 04/13] fix some tests --- .../tests/fail/invalid_verify_with_field_type.stderr | 4 ++-- .../tests/fail/invalid_verify_with_struct_type.stderr | 4 ++-- .../tests/pass/verify_with_field_visitor.rs | 2 +- .../tests/pass/verify_with_struct_visitor.rs | 2 +- 4 files changed, 6 insertions(+), 6 deletions(-) diff --git a/packable/packable-derive-test/tests/fail/invalid_verify_with_field_type.stderr b/packable/packable-derive-test/tests/fail/invalid_verify_with_field_type.stderr index 389de8a..93e280d 100644 --- a/packable/packable-derive-test/tests/fail/invalid_verify_with_field_type.stderr +++ b/packable/packable-derive-test/tests/fail/invalid_verify_with_field_type.stderr @@ -12,6 +12,6 @@ error[E0308]: mismatched types note: function defined here --> tests/fail/invalid_verify_with_field_type.rs:24:4 | -24 | fn verify_value(&value: &u64) -> Result<(), PickyError> { - | ^^^^^^^^^^^^ ------------ +24 | fn verify_value(&value: &u64) -> Result<(), PickyError> { + | ^^^^^^^^^^^^ ------------ = note: this error originates in the derive macro `Packable` (in Nightly builds, run with -Z macro-backtrace for more info) diff --git a/packable/packable-derive-test/tests/fail/invalid_verify_with_struct_type.stderr b/packable/packable-derive-test/tests/fail/invalid_verify_with_struct_type.stderr index 5d95333..f7faa8e 100644 --- a/packable/packable-derive-test/tests/fail/invalid_verify_with_struct_type.stderr +++ b/packable/packable-derive-test/tests/fail/invalid_verify_with_struct_type.stderr @@ -12,6 +12,6 @@ error[E0308]: mismatched types note: function defined here --> tests/fail/invalid_verify_with_struct_type.rs:24:4 | -24 | fn verify(&value: &u64) -> Result<(), PickyError> { - | ^^^^^^ ------------ +24 | fn verify(&value: &u64) -> Result<(), PickyError> { + | ^^^^^^ ------------ = note: this error originates in the derive macro `Packable` (in Nightly builds, run with -Z macro-backtrace for more info) diff --git a/packable/packable-derive-test/tests/pass/verify_with_field_visitor.rs b/packable/packable-derive-test/tests/pass/verify_with_field_visitor.rs index 2d20ccd..30bbbbd 100644 --- a/packable/packable-derive-test/tests/pass/verify_with_field_visitor.rs +++ b/packable/packable-derive-test/tests/pass/verify_with_field_visitor.rs @@ -21,7 +21,7 @@ impl From for PickyError { } } -fn verify(&value: &u64) -> Result<(), PickyError> { +fn verify_value(&value: &u64) -> Result<(), PickyError> { if value == 42 { Ok(()) } else { diff --git a/packable/packable-derive-test/tests/pass/verify_with_struct_visitor.rs b/packable/packable-derive-test/tests/pass/verify_with_struct_visitor.rs index 83a454f..48ffbfc 100644 --- a/packable/packable-derive-test/tests/pass/verify_with_struct_visitor.rs +++ b/packable/packable-derive-test/tests/pass/verify_with_struct_visitor.rs @@ -21,7 +21,7 @@ impl From for PickyError { } } -fn verify(value: &Picky) -> Result<(), PickyError> { +fn verify(value: &Picky, _: &()) -> Result<(), PickyError> { if value.0 == 42 { Ok(()) } else { From e1d4b06b901837e16a38695b4a0cb634b620df41 Mon Sep 17 00:00:00 2001 From: Thibault Martinez Date: Thu, 8 Feb 2024 21:20:54 +0100 Subject: [PATCH 05/13] Fix 2 tests --- .../tests/fail/invalid_verify_with_field_type.stderr | 8 ++++---- .../tests/fail/invalid_verify_with_struct_type.stderr | 8 ++++---- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/packable/packable-derive-test/tests/fail/invalid_verify_with_field_type.stderr b/packable/packable-derive-test/tests/fail/invalid_verify_with_field_type.stderr index 93e280d..73ec1a4 100644 --- a/packable/packable-derive-test/tests/fail/invalid_verify_with_field_type.stderr +++ b/packable/packable-derive-test/tests/fail/invalid_verify_with_field_type.stderr @@ -2,10 +2,10 @@ error[E0308]: mismatched types --> tests/fail/invalid_verify_with_field_type.rs:32:10 | 32 | #[derive(Packable)] - | ^^^^^^^^ - | | - | expected `&u64`, found `&u8` - | arguments to this function are incorrect + | ^^^^^^^^ expected `&u64`, found `&u8` +33 | #[packable(unpack_error = PickyError)] +34 | pub struct Picky(#[packable(verify_with = verify_value)] u8); + | ------------ arguments to this function are incorrect | = note: expected reference `&u64` found reference `&u8` diff --git a/packable/packable-derive-test/tests/fail/invalid_verify_with_struct_type.stderr b/packable/packable-derive-test/tests/fail/invalid_verify_with_struct_type.stderr index f7faa8e..3d27309 100644 --- a/packable/packable-derive-test/tests/fail/invalid_verify_with_struct_type.stderr +++ b/packable/packable-derive-test/tests/fail/invalid_verify_with_struct_type.stderr @@ -2,10 +2,10 @@ error[E0308]: mismatched types --> tests/fail/invalid_verify_with_struct_type.rs:32:10 | 32 | #[derive(Packable)] - | ^^^^^^^^ - | | - | expected `&u64`, found `&Picky` - | arguments to this function are incorrect + | ^^^^^^^^ expected `&u64`, found `&Picky` +33 | #[packable(unpack_error = PickyError)] +34 | #[packable(verify_with = verify)] + | ------ arguments to this function are incorrect | = note: expected reference `&u64` found reference `&Picky` From 38751680e74cfb8ce4768f89c5d563f37f569a99 Mon Sep 17 00:00:00 2001 From: Alex Coats Date: Thu, 8 Feb 2024 15:23:28 -0500 Subject: [PATCH 06/13] fix last test --- .../tests/pass/verify_with_field_visitor.rs | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/packable/packable-derive-test/tests/pass/verify_with_field_visitor.rs b/packable/packable-derive-test/tests/pass/verify_with_field_visitor.rs index 30bbbbd..724e31e 100644 --- a/packable/packable-derive-test/tests/pass/verify_with_field_visitor.rs +++ b/packable/packable-derive-test/tests/pass/verify_with_field_visitor.rs @@ -21,12 +21,8 @@ impl From for PickyError { } } -fn verify_value(&value: &u64) -> Result<(), PickyError> { - if value == 42 { - Ok(()) - } else { - Err(PickyError(value as u8)) - } +fn verify_value(&value: &u8, _: &()) -> Result<(), PickyError> { + if value == 42 { Ok(()) } else { Err(PickyError(value)) } } #[derive(Packable)] From 7c7304e12b6558afc1e64724664741173f6f6f66 Mon Sep 17 00:00:00 2001 From: Alex Coats Date: Thu, 8 Feb 2024 15:39:23 -0500 Subject: [PATCH 07/13] version + changelog --- packable/packable-derive-test/Cargo.toml | 2 +- packable/packable-derive/CHANGELOG.md | 7 +++++++ packable/packable-derive/Cargo.toml | 2 +- packable/packable/CHANGELOG.md | 12 ++++++++++++ packable/packable/Cargo.toml | 4 ++-- 5 files changed, 23 insertions(+), 4 deletions(-) diff --git a/packable/packable-derive-test/Cargo.toml b/packable/packable-derive-test/Cargo.toml index 3685bff..89ea0c0 100644 --- a/packable/packable-derive-test/Cargo.toml +++ b/packable/packable-derive-test/Cargo.toml @@ -16,7 +16,7 @@ name = "tests" path = "tests/lib.rs" [dev-dependencies] -packable = { version = "=0.10.1", path = "../packable", default-features = false } +packable = { version = "=0.11.0", path = "../packable", default-features = false } rustversion = { version = "1.0.14", default-features = false } trybuild = { version = "1.0.88", default-features = false, features = ["diff"] } diff --git a/packable/packable-derive/CHANGELOG.md b/packable/packable-derive/CHANGELOG.md index bd5c577..575e22c 100644 --- a/packable/packable-derive/CHANGELOG.md +++ b/packable/packable-derive/CHANGELOG.md @@ -19,6 +19,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Security --> +## 0.10.0 - 2024-02-08 + +### Changed + +- Updated to new `Packable` trait. +- `verify_with` function is no longer called if the visitor is `None`; + ## 0.9.0 - 2023-11-17 ### Changed diff --git a/packable/packable-derive/Cargo.toml b/packable/packable-derive/Cargo.toml index 8e4554b..3509cbc 100644 --- a/packable/packable-derive/Cargo.toml +++ b/packable/packable-derive/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "packable-derive" -version = "0.9.0" +version = "0.10.0" authors = ["IOTA Stiftung"] edition = "2021" description = "Derive macro for the `packable` crate." diff --git a/packable/packable/CHANGELOG.md b/packable/packable/CHANGELOG.md index 0c545a8..89416f7 100644 --- a/packable/packable/CHANGELOG.md +++ b/packable/packable/CHANGELOG.md @@ -19,6 +19,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Security --> +## 0.11.0 - 2024-02-08 + +### Added + +- `Packable::unpack_inner`, `Packable::unpack_verified`, and `Packable::unpack_unverified`; + +### Changed + +- Removed `Default` bound from `Packable::UnpackVisitor`; +- Replaced `const VERIFY` in `Packable::unpack` with `Option<&Self::UnpackVisitor>`, which can be checked instead; +- Renamed `PackableExt::unpack_verified` and `unpack_unverified` to `unpack_bytes_verified` and `unpack_bytes_unverified`; + ## 0.10.1 - 2024-01-08 ### Added diff --git a/packable/packable/Cargo.toml b/packable/packable/Cargo.toml index f2ff1de..3acff99 100644 --- a/packable/packable/Cargo.toml +++ b/packable/packable/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "packable" -version = "0.10.1" +version = "0.11.0" authors = ["IOTA Stiftung"] edition = "2021" description = "A crate for packing and unpacking binary representations." @@ -20,7 +20,7 @@ usize = [] autocfg = { version = "1.1.0", default-features = false } [dependencies] -packable-derive = { version = "=0.9.0", path = "../packable-derive", default-features = false } +packable-derive = { version = "=0.10.0", path = "../packable-derive", default-features = false } hashbrown = { version = "0.14.3", default-features = false, features = [ "ahash", From 6a28c13e931e527afa934af9ec5bf81c874c656a Mon Sep 17 00:00:00 2001 From: Thibault Martinez Date: Fri, 9 Feb 2024 12:37:25 +0100 Subject: [PATCH 08/13] Apply suggestions from code review --- packable/packable-derive/CHANGELOG.md | 2 +- packable/packable/CHANGELOG.md | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/packable/packable-derive/CHANGELOG.md b/packable/packable-derive/CHANGELOG.md index 575e22c..c104b8b 100644 --- a/packable/packable-derive/CHANGELOG.md +++ b/packable/packable-derive/CHANGELOG.md @@ -19,7 +19,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Security --> -## 0.10.0 - 2024-02-08 +## 0.10.0 - 2024-02-09 ### Changed diff --git a/packable/packable/CHANGELOG.md b/packable/packable/CHANGELOG.md index 89416f7..930d3c1 100644 --- a/packable/packable/CHANGELOG.md +++ b/packable/packable/CHANGELOG.md @@ -19,7 +19,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Security --> -## 0.11.0 - 2024-02-08 +## 0.11.0 - 2024-02-09 ### Added From 90caad888479706d78d2db8ac3da674072721f51 Mon Sep 17 00:00:00 2001 From: Alex Coats Date: Fri, 9 Feb 2024 08:27:35 -0500 Subject: [PATCH 09/13] fix no_std --- packable/packable/Cargo.toml | 1 + 1 file changed, 1 insertion(+) diff --git a/packable/packable/Cargo.toml b/packable/packable/Cargo.toml index 3acff99..0c2019c 100644 --- a/packable/packable/Cargo.toml +++ b/packable/packable/Cargo.toml @@ -29,4 +29,5 @@ hashbrown = { version = "0.14.3", default-features = false, features = [ primitive-types = { version = "0.12.2", default-features = false, optional = true } serde = { version = "1.0.195", default-features = false, features = [ "derive", + "alloc" ], optional = true } From baa605624ce625d44fb4a8075a97d8ea5f91ab18 Mon Sep 17 00:00:00 2001 From: Alex Coats Date: Fri, 9 Feb 2024 08:28:53 -0500 Subject: [PATCH 10/13] review --- packable/packable/tests/common/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packable/packable/tests/common/mod.rs b/packable/packable/tests/common/mod.rs index 9da3797..62c462e 100644 --- a/packable/packable/tests/common/mod.rs +++ b/packable/packable/tests/common/mod.rs @@ -60,7 +60,7 @@ where let mut packer = IoPacker::new(Vec::new()); packable.pack(&mut packer).unwrap(); let mut unpacker = IoUnpacker::new(packer.as_slice()); - let unpacked = P::unpack(&mut unpacker, None).unwrap(); + let unpacked = P::unpack(&mut unpacker, Some(&())).unwrap(); assert_eq!(packable, &unpacked); generic_test_pack_to_slice_unpack_verified(packable); From b3fa501d0fe78df87a2c5de478dc07d7a4c0d985 Mon Sep 17 00:00:00 2001 From: Alex Coats Date: Fri, 9 Feb 2024 08:37:40 -0500 Subject: [PATCH 11/13] fix last test error --- .../tests/fail/incorrect_tag_enum.stderr | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/packable/packable-derive-test/tests/fail/incorrect_tag_enum.stderr b/packable/packable-derive-test/tests/fail/incorrect_tag_enum.stderr index 4deeac4..dbe2b67 100644 --- a/packable/packable-derive-test/tests/fail/incorrect_tag_enum.stderr +++ b/packable/packable-derive-test/tests/fail/incorrect_tag_enum.stderr @@ -26,3 +26,9 @@ note: method defined here | fn pack(&self, packer: &mut P) -> Result<(), P::Error>; | ^^^^ = note: this error originates in the derive macro `Packable` (in Nightly builds, run with -Z macro-backtrace for more info) + +error: could not evaluate constant pattern + --> tests/fail/incorrect_tag_enum.rs:14:22 + | +14 | #[packable(tag = 0u32)] + | ^^^^ From 7fb0f3c6c353dab2f87788cbe88fcee8223fa5e9 Mon Sep 17 00:00:00 2001 From: Thibault Martinez Date: Fri, 9 Feb 2024 14:54:40 +0100 Subject: [PATCH 12/13] Fix test --- .../tests/fail/incorrect_tag_enum.stderr | 6 ------ packable/packable-derive-test/tests/lib.rs | 2 +- 2 files changed, 1 insertion(+), 7 deletions(-) diff --git a/packable/packable-derive-test/tests/fail/incorrect_tag_enum.stderr b/packable/packable-derive-test/tests/fail/incorrect_tag_enum.stderr index dbe2b67..4deeac4 100644 --- a/packable/packable-derive-test/tests/fail/incorrect_tag_enum.stderr +++ b/packable/packable-derive-test/tests/fail/incorrect_tag_enum.stderr @@ -26,9 +26,3 @@ note: method defined here | fn pack(&self, packer: &mut P) -> Result<(), P::Error>; | ^^^^ = note: this error originates in the derive macro `Packable` (in Nightly builds, run with -Z macro-backtrace for more info) - -error: could not evaluate constant pattern - --> tests/fail/incorrect_tag_enum.rs:14:22 - | -14 | #[packable(tag = 0u32)] - | ^^^^ diff --git a/packable/packable-derive-test/tests/lib.rs b/packable/packable-derive-test/tests/lib.rs index 82c374e..475044d 100644 --- a/packable/packable-derive-test/tests/lib.rs +++ b/packable/packable-derive-test/tests/lib.rs @@ -60,4 +60,4 @@ macro_rules! make_test { #[rustversion::stable] make_test!(); #[rustversion::not(stable)] -make_test!(); +make_test!(incorrect_tag_enum); From 4bed051a2367ff2d3f5fe3433276505de2595bd9 Mon Sep 17 00:00:00 2001 From: Thibault Martinez Date: Fri, 9 Feb 2024 15:25:38 +0100 Subject: [PATCH 13/13] Update packable/packable-derive/CHANGELOG.md --- packable/packable-derive/CHANGELOG.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packable/packable-derive/CHANGELOG.md b/packable/packable-derive/CHANGELOG.md index c104b8b..22dbabb 100644 --- a/packable/packable-derive/CHANGELOG.md +++ b/packable/packable-derive/CHANGELOG.md @@ -23,7 +23,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Changed -- Updated to new `Packable` trait. +- Updated to new `Packable` trait; - `verify_with` function is no longer called if the visitor is `None`; ## 0.9.0 - 2023-11-17