Implementing templates

Signed-off-by: Jonathan Woollet-Light <[email protected]>>

Author: Jonathan Woollett-Light

src/arch/src/x86_64/msr.rs

@@ -315,14 +315,13 @@ pub fn set_msrs(
     let msrs = Msrs::from_entries(&msr_entries).map_err(SetMSRsError::Create)?;
     vcpu.set_msrs(&msrs)
         .map_err(SetMSRsError::Set)
-        .and_then(|msrs_written|
+        .and_then(|msrs_written| {
             if msrs_written as u32 == msrs.as_fam_struct_ref().nmsrs {
                 Ok(())
-            }
-            else {
+            } else {
                 Err(SetMSRsError::Incomplete)
             }
-        )
+        })
 }
 
 /// Returns the list of supported, serializable MSRs.

src/bit-fields-macros/src/lib.rs

@@ -58,7 +58,7 @@ pub fn bitfield(item: proc_macro::TokenStream) -> proc_macro::TokenStream {
     let struct_name = match token_stream_iter.next() {
         Some(TokenTree::Ident(ident)) => ident,
         Some(token) => return diagnostic(token.span(), IDENT_ERR),
-        _ => panic!("{}", IDENT_ERR),
+        None => panic!("{}", IDENT_ERR),
     };
 
     let struct_data_type: proc_macro2::Ident = match token_stream_iter.nth(1) {
@@ -67,7 +67,7 @@ pub fn bitfield(item: proc_macro::TokenStream) -> proc_macro::TokenStream {
             _ => return diagnostic(ident.span(), TYPE_ERR),
         },
         Some(token) => return diagnostic(token.span(), TYPE_ERR),
-        _ => panic!("{}", TYPE_ERR),
+        None => panic!("{}", TYPE_ERR),
     };
 
     let bits_len: u8 = match struct_data_type.to_string().as_str() {
@@ -446,8 +446,8 @@ pub fn bitfield(item: proc_macro::TokenStream) -> proc_macro::TokenStream {
                             #[cfg(feature = "field_map")]
                             write!(
                                 &mut field_setting_hashmap,
-                                "map.insert(String::from(\"{field_ident}\"),\
-                                 {struct_data_type}::from(&bit_field.{field_ident}));",
+                                "map.insert(String::from(\"{field_ident}\"),{struct_data_type}::\
+                                 from(&bit_field.{field_ident}));",
                                 struct_data_type = struct_data_type,
                                 field_ident = field_ident
                             )
@@ -478,7 +478,7 @@ pub fn bitfield(item: proc_macro::TokenStream) -> proc_macro::TokenStream {
             // The bit flag case
             Some(TokenTree::Punct(punct)) if punct.as_char() == ',' => add_bit_flags(),
             None => add_bit_flags(),
-            _ => return diagnostic(field_ident.span(), FIELDS_ERR),
+            Some(_) => return diagnostic(field_ident.span(), FIELDS_ERR),
         }
         // We skip the punctuation for the next iteration.
         fields_iter.next();
@@ -658,13 +658,13 @@ pub fn bitfield(item: proc_macro::TokenStream) -> proc_macro::TokenStream {
     #[cfg(feature = "flag_set")]
     let flag_set = quote! {
         impl<T:std::fmt::Display> std::convert::TryFrom<std::collections::HashSet<T>> for #struct_name {
-            type Error = bit_fields::TryFromFlagSetErr;
+            type Error = bit_fields::TryFromFlagSetError;
             fn try_from(set: std::collections::HashSet<T>) -> Result<Self,Self::Error> {
                 let mut base = Self::from(0);
                 for key in set.into_iter() {
                     match key.to_string().as_str() {
                         #flag_matching_from_hashset
-                        _ => return Err(bit_fields::TryFromFlagSetErr)
+                        _ => return Err(bit_fields::TryFromFlagSetError)
                     }
                 }
                 Ok(base)
@@ -687,13 +687,13 @@ pub fn bitfield(item: proc_macro::TokenStream) -> proc_macro::TokenStream {
     #[cfg(feature = "field_map")]
     let field_map = quote! {
         impl<T:std::fmt::Display> std::convert::TryFrom<std::collections::HashMap<T,#struct_data_type>> for #struct_name {
-            type Error = bit_fields::TryFromFieldMapErr;
+            type Error = bit_fields::TryFromFieldMapError;
             fn try_from(set: std::collections::HashMap<T,#struct_data_type>) -> Result<Self,Self::Error> {
                 let mut base = Self::from(0);
                 for (key,value) in set.into_iter() {
                     match key.to_string().as_str() {
                         #field_matching_from_hashmap
-                        _ => return Err(bit_fields::TryFromFieldMapErr::UnknownField)
+                        _ => return Err(bit_fields::TryFromFieldMapError::UnknownField)
                     }
                 }
                 Ok(base)
@@ -713,19 +713,19 @@ pub fn bitfield(item: proc_macro::TokenStream) -> proc_macro::TokenStream {
     #[cfg(all(feature = "flag_set", feature = "field_map"))]
     let set_map_conversions = quote! {
         impl<T:std::fmt::Display> std::convert::TryFrom<(std::collections::HashSet<T>,std::collections::HashMap<T,#struct_data_type>)> for #struct_name {
-            type Error = bit_fields::TryFromFlagSetAndFieldMapErr;
+            type Error = bit_fields::TryFromFlagSetAndFieldMapError;
             fn try_from((set,map):(std::collections::HashSet<T>,std::collections::HashMap<T,#struct_data_type>)) -> Result<Self,Self::Error> {
                 let mut base = Self::from(0);
                 for key in set.into_iter() {
                     match key.to_string().as_str() {
                         #flag_matching_from_hashset
-                        _ => return Err(bit_fields::TryFromFlagSetAndFieldMapErr::FlagSet(bit_fields::TryFromFlagSetErr))
+                        _ => return Err(bit_fields::TryFromFlagSetAndFieldMapError::FlagSet(bit_fields::TryFromFlagSetError))
                     }
                 }
                 for (key,value) in map.into_iter() {
                     match key.to_string().as_str() {
                         #field_matching_from_hashmap
-                        _ => return Err(bit_fields::TryFromFlagSetAndFieldMapErr::FieldMap(bit_fields::TryFromFieldMapErr::UnknownField))
+                        _ => return Err(bit_fields::TryFromFlagSetAndFieldMapError::FieldMap(bit_fields::TryFromFieldMapError::UnknownField))
                     }
                 }
                 Ok(base)

src/bit-fields/Cargo.toml

@@ -8,9 +8,13 @@ edition = "2018"
 [dependencies] 
 bit-fields-macros = { path = "../bit-fields-macros" }
 serde = { version = "1.0.139", features=["derive"], optional = true }
+thiserror = "1.0.32"
+
+[dev-dependencies]
+serde_json = "1.0.83"
 
 [features]
-default = ["set_theory","bit_index","flag_set","field_map","display","cmp_flags"]
+default = ["set_theory","bit_index","flag_set","field_map","display","cmp_flags","serde_feature"]
 set_theory = ["bit-fields-macros/set_theory"]
 bit_index = ["bit-fields-macros/bit_index"]
 flag_set = ["bit-fields-macros/flag_set"]