Merge pull request sharksforarms#335 from IniterWorker/feature/reader…

…-catch-all

Add `default` attribute for DekuRead enums

deku-derive/src/lib.rs

@@ -546,6 +546,9 @@ struct VariantData {
 
  /// variant `id_pat` value
  id_pat: Option<TokenStream>,
+
+ /// variant `default` option
+ default: Option<bool>,
 }
 
 impl VariantData {
@@ -568,6 +571,7 @@ impl VariantData {
  writer: receiver.writer?,
  id: receiver.id,
  id_pat: receiver.id_pat?,
+ default: receiver.default,
  };
 
  VariantData::validate(&ret)?;
@@ -843,6 +847,10 @@ struct DekuVariantReceiver {
  /// variant `id_pat` value
  #[darling(default = "default_res_opt", map = "map_litstr_as_tokenstream")]
  id_pat: Result<Option<TokenStream>, ReplacementError>,
+
+ /// variant `id` value
+ #[darling(default)]
+ default: Option<bool>,
 }
 
 /// Entry function for `DekuRead` proc-macro

deku-derive/src/macros/deku_read.rs

@@ -156,6 +156,7 @@ fn emit_enum(input: &DekuData) -> Result<TokenStream, syn::Error> {
  let magic_read = emit_magic_read(input);
 
  let mut has_default_match = false;
+ let mut default_reader = None;
  let mut pre_match_tokens = Vec::with_capacity(variants.len());
  let mut variant_matches = Vec::with_capacity(variants.len());
  let mut deku_ids = Vec::with_capacity(variants.len());
@@ -198,6 +199,7 @@ fn emit_enum(input: &DekuData) -> Result<TokenStream, syn::Error> {
 
  let variant_ident = &variant.ident;
  let variant_reader = &variant.reader;
+ let variant_has_default = variant.default.unwrap_or(false);
 
  let variant_read_func = if variant_reader.is_some() {
  quote! { #variant_reader; }
@@ -210,7 +212,6 @@ fn emit_enum(input: &DekuData) -> Result<TokenStream, syn::Error> {
  .iter()
  .filter(|f| !f.is_temp)
  .map(|f| &f.field_ident);
-
  let internal_fields = gen_internal_field_idents(variant_is_named, field_idents);
  let initialize_enum =
  super::gen_enum_init(variant_is_named, variant_ident, internal_fields);
@@ -243,6 +244,16 @@ fn emit_enum(input: &DekuData) -> Result<TokenStream, syn::Error> {
  }
  };
 
+ // register `default`
+ if default_reader.is_some() && variant_has_default {
+ return Err(syn::Error::new(
+ variant.ident.span(),
+ "DekuRead: `default` must be specified only once",
+ ));
+ } else if default_reader.is_none() && variant_has_default {
+ default_reader = Some(variant_read_func.clone())
+ }
+
  variant_matches.push(quote! {
  #variant_id => {
  #variant_read_func
@@ -251,7 +262,7 @@ fn emit_enum(input: &DekuData) -> Result<TokenStream, syn::Error> {
  }
 
  // if no default match, return error
- if !has_default_match {
+ if !has_default_match && default_reader.is_none() {
  variant_matches.push(quote! {
  _ => {
  return Err(::#crate_::DekuError::Parse(
@@ -265,6 +276,17 @@ fn emit_enum(input: &DekuData) -> Result<TokenStream, syn::Error> {
  });
  }
 
+ // if default
+ if !has_default_match {
+ if let Some(variant_read_func) = default_reader {
+ variant_matches.push(quote! {
+ _ => {
+ #variant_read_func
+ }
+ });
+ }
+ }
+
  let variant_id_read = if id.is_some() {
  quote! {
  let (__deku_new_rest, __deku_variant_id) = (__deku_rest, (#id));

examples/enums_catch_all.rs

@@ -0,0 +1,30 @@
+use deku::prelude::*;
+use hexlit::hex;
+use std::convert::TryFrom;
+use std::convert::TryInto;
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug, DekuWrite, DekuRead)]
+#[deku(type = "u8")]
+#[non_exhaustive]
+#[repr(u8)]
+pub enum DekuTest {
+ /// A
+ #[deku(id = "1")]
+ A = 0,
+ /// B
+ #[deku(id = "2")]
+ B = 1,
+ /// C
+ #[deku(id = "3", default)]
+ C = 2,
+}
+
+fn main() {
+ let input = hex!("0A").to_vec();
+ let output = hex!("03").to_vec();
+
+ let ret_read = DekuTest::try_from(input.as_slice()).unwrap();
+ assert_eq!(DekuTest::C, ret_read);
+ let ret_write: Vec<u8> = ret_read.try_into().unwrap();
+ assert_eq!(output.to_vec(), ret_write);
+}

src/lib.rs

@@ -149,14 +149,17 @@ First the "type" is read using the `type`, then is matched against the
 variants given `id`. What happens after is the same as structs!
 
 This is implemented with the [id](/attributes/index.html#id),
-[id_pat](/attributes/index.html#id_pat) and
+[id_pat](/attributes/index.html#id_pat), [default](/attributes/index.html#default) and
 [type](attributes#type) attributes. See these for more examples.
 
 If no `id` is specified, the variant will default to it's discriminant value.
 
-If no variant can be matched, a [DekuError::Parse](crate::error::DekuError)
+If no variant can be matched and the `default` is not provided, a [DekuError::Parse](crate::error::DekuError)
 error will be returned.
 
+If no variant can be matched and the `default` is provided, a variant will be returned
+based on the field marked with `default`.
+
 Example:
 
 ```rust

tests/test_catch_all.rs

@@ -0,0 +1,86 @@
+#[cfg(test)]
+mod test {
+ use deku::prelude::*;
+ use std::convert::TryFrom;
+ use std::convert::TryInto;
+
+ /// Basic test struct
+ #[derive(Clone, Copy, PartialEq, Eq, Debug, DekuWrite, DekuRead)]
+ #[deku(type = "u8")]
+ #[non_exhaustive]
+ #[repr(u8)]
+ pub enum BasicMapping {
+ /// A
+ A = 0,
+ /// B
+ B = 1,
+ /// C
+ #[deku(default)]
+ C = 2,
+ }
+
+ /// Advanced test struct
+ #[derive(Clone, Copy, PartialEq, Eq, Debug, DekuWrite, DekuRead)]
+ #[deku(type = "u8")]
+ #[non_exhaustive]
+ #[repr(u8)]
+ pub enum AdvancedRemapping {
+ /// A
+ #[deku(id = "1")]
+ A = 0,
+ /// B
+ #[deku(id = "2")]
+ B = 1,
+ /// C
+ #[deku(id = "3", default)]
+ C = 2,
+ }
+
+ #[test]
+ fn test_basic_a() {
+ let input = [0u8];
+ let ret_read = BasicMapping::try_from(input.as_slice()).unwrap();
+ assert_eq!(BasicMapping::A, ret_read);
+ let ret_write: Vec<u8> = ret_read.try_into().unwrap();
+ assert_eq!(input.to_vec(), ret_write);
+ }
+
+ #[test]
+ fn test_basic_c() {
+ let input = [2u8];
+ let ret_read = BasicMapping::try_from(input.as_slice()).unwrap();
+ assert_eq!(BasicMapping::C, ret_read);
+ let ret_write: Vec<u8> = ret_read.try_into().unwrap();
+ assert_eq!(input.to_vec(), ret_write);
+ }
+
+ #[test]
+ fn test_basic_pattern() {
+ let input = [10u8];
+ let output = [BasicMapping::C as u8];
+ let ret_read = BasicMapping::try_from(input.as_slice()).unwrap();
+ assert_eq!(BasicMapping::C, ret_read);
+ let ret_write: Vec<u8> = ret_read.try_into().unwrap();
+ assert_eq!(output.to_vec(), ret_write);
+ }
+
+ #[test]
+ fn test_advanced_remapping() {
+ let input = [1u8];
+ let output = [1u8];
+ let ret_read = AdvancedRemapping::try_from(input.as_slice()).unwrap();
+ assert_eq!(AdvancedRemapping::A, ret_read);
+ let ret_write: Vec<u8> = ret_read.try_into().unwrap();
+ assert_eq!(output.to_vec(), ret_write);
+ }
+
+ #[test]
+ fn test_advanced_remapping_default_field() {
+ let input = [10u8];
+ let output = [3u8];
+ let ret_read = AdvancedRemapping::try_from(input.as_slice()).unwrap();
+ assert_eq!(AdvancedRemapping::C, ret_read);
+ let ret_write: Vec<u8> = ret_read.try_into().unwrap();
+ assert_eq!(output.to_vec(), ret_write);
+ }
+}

tests/test_compile/cases/catch_all_multiple.rs

@@ -0,0 +1,12 @@
+use deku::prelude::*;
+
+#[derive(DekuRead)]
+#[deku(type = "u8")]
+enum Test1 {
+ #[deku(default)]
+ A = 1,
+ #[deku(default)]
+ B = 2,
+}
+
+fn main() {}

tests/test_compile/cases/catch_all_multiple.stderr

@@ -0,0 +1,5 @@
+error: DekuRead: `default` must be specified only once
+ --> tests/test_compile/cases/catch_all_multiple.rs:9:5
+ |
+9 | B = 2,
+ | ^