berkus
/
bincode-orig
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Fixed derive impl on an empty enum (#462) 

* Fixed derive impl on an empty enum

* Added DecodeError::EmptyEnum in case a user tries to decode an empty enum
This commit is contained in:
Trangar 2022-01-08 12:39:03 +01:00 committed by GitHub
parent 030905e7d5
commit 99707d0d0b
3 changed files with 131 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

197
derive/src/derive_enum.rs
View File

@ -35,6 +35,9 @@ impl DeriveEnum {
fn_body.ident_str("match"); fn_body.ident_str("match");
fn_body.ident_str("self"); fn_body.ident_str("self");
fn_body.group(Delimiter::Brace, |match_body| { fn_body.group(Delimiter::Brace, |match_body| {
if self.variants.is_empty() {
self.encode_empty_enum_case(match_body)?;
}
for (variant_index, variant) in self.iter_fields() { for (variant_index, variant) in self.iter_fields() {
// Self::Variant // Self::Variant
match_body.ident_str("Self"); match_body.ident_str("Self");
@ -101,18 +104,24 @@ impl DeriveEnum {
?; ?;
} }
} }
body.push_parsed("Ok(())")?;
Ok(()) Ok(())
})?; })?;
match_body.punct(','); match_body.punct(',');
} }
Ok(()) Ok(())
})?; })?;
fn_body.push_parsed("Ok(())")?;
Ok(()) Ok(())
})?; })?;
Ok(()) Ok(())
} }
/// If we're encoding an empty enum, we need to add an empty case in the form of:
/// `_ => core::unreachable!(),`
fn encode_empty_enum_case(&self, builder: &mut StreamBuilder) -> Result {
builder.push_parsed("_ => core::unreachable!()").map(|_| ())
}
/// Build the catch-all case for an int-to-enum decode implementation /// Build the catch-all case for an int-to-enum decode implementation
fn invalid_variant_case(&self, enum_name: &str, result: &mut StreamBuilder) -> Result { fn invalid_variant_case(&self, enum_name: &str, result: &mut StreamBuilder) -> Result {
// we'll be generating: // we'll be generating:
@ -195,57 +204,61 @@ impl DeriveEnum {
.with_arg("mut decoder", "D") .with_arg("mut decoder", "D")
.with_return_type("core::result::Result<Self, bincode::error::DecodeError>") .with_return_type("core::result::Result<Self, bincode::error::DecodeError>")
.body(|fn_builder| { .body(|fn_builder| {
fn_builder if self.variants.is_empty() {
.push_parsed( fn_builder.push_parsed("core::result::Result::Err(bincode::error::DecodeError::EmptyEnum { type_name: core::any::type_name::<Self>() })")?;
"let variant_index = <u32 as bincode::Decode>::decode(&mut decoder)?;", } else {
)?; fn_builder
fn_builder.push_parsed("match variant_index")?; .push_parsed(
fn_builder.group(Delimiter::Brace, |variant_case| { "let variant_index = <u32 as bincode::Decode>::decode(&mut decoder)?;",
for (mut variant_index, variant) in self.iter_fields() { )?;
// idx => Ok(..) fn_builder.push_parsed("match variant_index")?;
if variant_index.len() > 1 { fn_builder.group(Delimiter::Brace, |variant_case| {
variant_case.push_parsed("x if x == ")?; for (mut variant_index, variant) in self.iter_fields() {
variant_case.extend(variant_index); // idx => Ok(..)
} else { if variant_index.len() > 1 {
variant_case.push(variant_index.remove(0)); variant_case.push_parsed("x if x == ")?;
} variant_case.extend(variant_index);
variant_case.puncts("=>"); } else {
variant_case.ident_str("Ok"); variant_case.push(variant_index.remove(0));
variant_case.group(Delimiter::Parenthesis, |variant_case_body| { }
// Self::Variant { } variant_case.puncts("=>");
// Self::Variant { 0: ..., 1: ... 2: ... }, variant_case.ident_str("Ok");
// Self::Variant { a: ..., b: ... c: ... }, variant_case.group(Delimiter::Parenthesis, |variant_case_body| {
variant_case_body.ident_str("Self"); // Self::Variant { }
variant_case_body.puncts("::"); // Self::Variant { 0: ..., 1: ... 2: ... },
variant_case_body.ident(variant.name.clone()); // Self::Variant { a: ..., b: ... c: ... },
variant_case_body.ident_str("Self");
variant_case_body.puncts("::");
variant_case_body.ident(variant.name.clone());
variant_case_body.group(Delimiter::Brace, |variant_body| { variant_case_body.group(Delimiter::Brace, |variant_body| {
let is_tuple = matches!(variant.fields, Fields::Tuple(_)); let is_tuple = matches!(variant.fields, Fields::Tuple(_));
for (idx, field) in variant.fields.names().into_iter().enumerate() { for (idx, field) in variant.fields.names().into_iter().enumerate() {
if is_tuple { if is_tuple {
variant_body.lit_usize(idx); variant_body.lit_usize(idx);
} else { } else {
variant_body.ident(field.unwrap_ident().clone()); variant_body.ident(field.unwrap_ident().clone());
}
variant_body.punct(':');
if field.attributes().has_attribute(FieldAttribute::WithSerde)? {
variant_body
.push_parsed("<bincode::serde::Compat<_> as bincode::Decode>::decode(&mut decoder)?.0,")?;
} else {
variant_body
.push_parsed("bincode::Decode::decode(&mut decoder)?,")?;
}
} }
variant_body.punct(':'); Ok(())
if field.attributes().has_attribute(FieldAttribute::WithSerde)? { })?;
variant_body
.push_parsed("<bincode::serde::Compat<_> as bincode::Decode>::decode(&mut decoder)?.0,")?;
} else {
variant_body
.push_parsed("bincode::Decode::decode(&mut decoder)?,")?;
}
}
Ok(()) Ok(())
})?; })?;
Ok(()) variant_case.punct(',');
})?; }
variant_case.punct(',');
}
// invalid idx // invalid idx
self.invalid_variant_case(&enum_name, variant_case) self.invalid_variant_case(&enum_name, variant_case)
})?; })?;
}
Ok(()) Ok(())
})?; })?;
Ok(()) Ok(())
@ -267,54 +280,58 @@ impl DeriveEnum {
.with_arg("mut decoder", "D") .with_arg("mut decoder", "D")
.with_return_type("core::result::Result<Self, bincode::error::DecodeError>") .with_return_type("core::result::Result<Self, bincode::error::DecodeError>")
.body(|fn_builder| { .body(|fn_builder| {
fn_builder if self.variants.is_empty() {
.push_parsed("let variant_index = <u32 as bincode::Decode>::decode(&mut decoder)?;")?; fn_builder.push_parsed("core::result::Result::Err(bincode::error::DecodeError::EmptyEnum { type_name: core::any::type_name::<Self>() })")?;
fn_builder.push_parsed("match variant_index")?; } else {
fn_builder.group(Delimiter::Brace, |variant_case| { fn_builder
for (mut variant_index, variant) in self.iter_fields() { .push_parsed("let variant_index = <u32 as bincode::Decode>::decode(&mut decoder)?;")?;
// idx => Ok(..) fn_builder.push_parsed("match variant_index")?;
if variant_index.len() > 1 { fn_builder.group(Delimiter::Brace, |variant_case| {
variant_case.push_parsed("x if x == ")?; for (mut variant_index, variant) in self.iter_fields() {
variant_case.extend(variant_index); // idx => Ok(..)
} else { if variant_index.len() > 1 {
variant_case.push(variant_index.remove(0)); variant_case.push_parsed("x if x == ")?;
} variant_case.extend(variant_index);
variant_case.puncts("=>"); } else {
variant_case.ident_str("Ok"); variant_case.push(variant_index.remove(0));
variant_case.group(Delimiter::Parenthesis, |variant_case_body| { }
// Self::Variant { } variant_case.puncts("=>");
// Self::Variant { 0: ..., 1: ... 2: ... }, variant_case.ident_str("Ok");
// Self::Variant { a: ..., b: ... c: ... }, variant_case.group(Delimiter::Parenthesis, |variant_case_body| {
variant_case_body.ident_str("Self"); // Self::Variant { }
variant_case_body.puncts("::"); // Self::Variant { 0: ..., 1: ... 2: ... },
variant_case_body.ident(variant.name.clone()); // Self::Variant { a: ..., b: ... c: ... },
variant_case_body.ident_str("Self");
variant_case_body.puncts("::");
variant_case_body.ident(variant.name.clone());
variant_case_body.group(Delimiter::Brace, |variant_body| { variant_case_body.group(Delimiter::Brace, |variant_body| {
let is_tuple = matches!(variant.fields, Fields::Tuple(_)); let is_tuple = matches!(variant.fields, Fields::Tuple(_));
for (idx, field) in variant.fields.names().into_iter().enumerate() { for (idx, field) in variant.fields.names().into_iter().enumerate() {
if is_tuple { if is_tuple {
variant_body.lit_usize(idx); variant_body.lit_usize(idx);
} else { } else {
variant_body.ident(field.unwrap_ident().clone()); variant_body.ident(field.unwrap_ident().clone());
}
variant_body.punct(':');
if field.attributes().has_attribute(FieldAttribute::WithSerde)? {
variant_body
.push_parsed("<bincode::serde::BorrowCompat<_> as bincode::BorrowDecode>::borrow_decode(&mut decoder)?.0,")?;
} else {
variant_body.push_parsed("bincode::de::BorrowDecode::borrow_decode(&mut decoder)?,")?;
}
} }
variant_body.punct(':'); Ok(())
if field.attributes().has_attribute(FieldAttribute::WithSerde)? { })?;
variant_body
.push_parsed("<bincode::serde::BorrowCompat<_> as bincode::BorrowDecode>::borrow_decode(&mut decoder)?.0,")?;
} else {
variant_body.push_parsed("bincode::de::BorrowDecode::borrow_decode(&mut decoder)?,")?;
}
}
Ok(()) Ok(())
})?; })?;
Ok(()) variant_case.punct(',');
})?; }
variant_case.punct(',');
}
// invalid idx // invalid idx
self.invalid_variant_case(&enum_name, variant_case) self.invalid_variant_case(&enum_name, variant_case)
})?; })?;
}
Ok(()) Ok(())
})?; })?;
Ok(()) Ok(())

6
src/error.rs
View File

@ -116,6 +116,12 @@ pub enum DecodeError {
found: usize, found: usize,
}, },
/// Tried to decode an enum with no variants
EmptyEnum {
/// The type that was being decoded
type_name: &'static str,
},
/// The decoder tried to decode a `CStr` or `CString`, but the incoming data contained a 0 byte /// The decoder tried to decode a `CStr` or `CString`, but the incoming data contained a 0 byte
#[cfg(feature = "std")] #[cfg(feature = "std")]
CStrNulError { CStrNulError {

18
tests/derive.rs
View File

@ -251,3 +251,21 @@ fn test_macro_newtype() {
assert_eq!(len, newtype_len); assert_eq!(len, newtype_len);
} }
} }
#[derive(bincode::Encode, bincode::Decode, Debug)]
pub enum EmptyEnum {}
#[derive(bincode::Encode, bincode::BorrowDecode, Debug)]
pub enum BorrowedEmptyEnum {}
#[test]
fn test_empty_enum_decode() {
let err =
bincode::decode_from_slice::<EmptyEnum, _>(&[], Configuration::standard()).unwrap_err();
assert_eq!(
err,
bincode::error::DecodeError::EmptyEnum {
type_name: "derive::EmptyEnum"
}
);
}