✨ Default for padding

Author: wrenger

README.md

@@ -108,7 +108,7 @@ struct MyBitfield {
     pub public: usize,
     /// padding
     #[bits(5)]
-    _p: u8,
+    __: u8,
 }
 
 /// A custom enum

src/lib.rs

@@ -98,7 +98,7 @@
 //!     pub public: usize,
 //!     /// padding
 //!     #[bits(5)]
-//!     _p: u8,
+//!     __: u8,
 //! }
 //!
 //! /// A custom enum
@@ -292,10 +292,11 @@ fn bitfield_inner(args: TokenStream, input: TokenStream) -> syn::Result<TokenStr
         #vis struct #name(#ty);
 
         impl #name {
-            /// Creates a new zero initialized bitfield.
+            /// Creates a new default initialized bitfield.
             #vis const fn new() -> Self {
-                Self(0)
+                let mut this = Self(0);
                 #( #defaults )*
+                this
             }
 
             #( #members )*
@@ -321,6 +322,7 @@ struct Member {
     offset: usize,
     bits: usize,
     base_ty: syn::Type,
+    default: TokenStream,
     inner: Option<MemberInner>,
 }
 
@@ -329,7 +331,6 @@ struct MemberInner {
     ty: syn::Type,
     attrs: Vec<syn::Attribute>,
     vis: syn::Visibility,
-    default: TokenStream,
     into: TokenStream,
     from: TokenStream,
 }
@@ -352,42 +353,50 @@ impl Member {
         let Field {
             bits,
             ty,
-            class: _,
-            default,
+            mut default,
             into,
             from,
         } = parse_field(&attrs, &ty, ignore)?;
 
         if bits > 0 && !ignore {
-            if default.is_empty() || into.is_empty() || from.is_empty() {
+            if into.is_empty() || from.is_empty() {
                 return Err(syn::Error::new(
                     ty.span(),
                     "Custom types require 'into', and 'from' in the #[bits] attribute",
                 ));
             }
 
+            if default.is_empty() {
+                default = quote!(#ty::from_bits(0));
+            }
+
             // remove our attribute
             attrs.retain(|a| !a.path().is_ident("bits"));
 
             Ok(Self {
                 offset,
                 bits,
                 base_ty,
+                default,
                 inner: Some(MemberInner {
                     ident,
                     ty,
                     attrs,
                     vis,
-                    default,
                     into,
                     from,
                 }),
             })
         } else {
+            if default.is_empty() {
+                default = quote!(0);
+            }
+
             Ok(Self {
                 offset,
                 bits,
                 base_ty,
+                default,
                 inner: None,
             })
         }
@@ -399,18 +408,20 @@ impl Member {
             let ident = &inner.ident;
             quote!(.field(#ident_str, &self.#ident()))
         } else {
-            Default::default()
+            quote!()
         }
     }
 
     fn default(&self) -> TokenStream {
+        let default = &self.default;
         if let Some(inner) = &self.inner {
             let ident = &inner.ident;
             let with_ident = format_ident!("with_{ident}");
-            let default = &inner.default;
-            quote!(.#with_ident(#default))
+            quote!(this = this.#with_ident(#default);)
         } else {
-            Default::default()
+            let offset = self.offset;
+            let base_ty = &self.base_ty;
+            quote!(this.0 |= (#default as #base_ty) << #offset;)
         }
     }
 }
@@ -421,7 +432,8 @@ impl ToTokens for Member {
             offset,
             bits,
             base_ty,
-            inner: Some(MemberInner { ident, ty, attrs, vis, default: _, into, from }),
+            default: _,
+            inner: Some(MemberInner { ident, ty, attrs, vis, into, from }),
         } = self else {
             return Default::default();
         };
@@ -441,23 +453,12 @@ impl ToTokens for Member {
             .map(ToTokens::to_token_stream)
             .collect();
 
-        let general = quote! {
-            const #bits_ident: usize = #bits;
-            const #offset_ident: usize = #offset;
-
-            #doc
-            #[doc = #location]
-            #vis fn #set_ident(&mut self, value: #ty) {
-                *self = self.#with_ident(value);
-            }
-        };
-
-        let bits = *bits as u32;
-        let mask: u128 = !0 >> (u128::BITS - bits);
+        let mask: u128 = !0 >> (u128::BITS - *bits as u32);
         let mask = syn::LitInt::new(&format!("0x{mask:x}"), Span::mixed_site());
 
         let code = quote! {
-            #general
+            const #bits_ident: usize = #bits;
+            const #offset_ident: usize = #offset;
 
             #doc
             #[doc = #location]
@@ -475,6 +476,12 @@ impl ToTokens for Member {
                 let this = (self.0 >> #offset) & #mask;
                 #from
             }
+            #doc
+            #[doc = #location]
+            #vis fn #set_ident(&mut self, value: #ty) {
+                *self = self.#with_ident(value);
+            }
+
         };
         tokens.extend(code);
     }
@@ -497,7 +504,6 @@ enum TypeClass {
 struct Field {
     bits: usize,
     ty: syn::Type,
-    class: TypeClass,
 
     default: TokenStream,
     into: TokenStream,
@@ -517,32 +523,28 @@ fn parse_field(attrs: &[syn::Attribute], ty: &syn::Type, ignore: bool) -> syn::R
         TypeClass::Bool => Field {
             bits: ty_bits,
             ty: ty.clone(),
-            class,
             default: quote!(false),
             into: quote!(this as _),
             from: quote!(this != 0),
         },
         TypeClass::SInt => Field {
             bits: ty_bits,
             ty: ty.clone(),
-            class,
             default: quote!(0),
             into: TokenStream::new(),
             from: TokenStream::new(),
         },
         TypeClass::UInt => Field {
             bits: ty_bits,
             ty: ty.clone(),
-            class,
             default: quote!(0),
             into: quote!(this as _),
             from: quote!(this as _),
         },
         TypeClass::Other => Field {
             bits: ty_bits,
             ty: ty.clone(),
-            class,
-            default: quote!(#ty::from_bits(0)),
+            default: TokenStream::new(),
             into: quote!(#ty::into_bits(this)),
             from: quote!(#ty::from_bits(this)),
         },
@@ -572,10 +574,10 @@ fn parse_field(attrs: &[syn::Attribute], ty: &syn::Type, ignore: bool) -> syn::R
                     }
                     ret.bits = bits;
                 }
-                if ignore && (default.is_some() || into.is_some() || from.is_some()) {
+                if ignore && (into.is_some() || from.is_some()) {
                     return Err(syn::Error::new(
                         default.span(),
-                        "'default', 'into', and 'from' are not (yet) supported on padding",
+                        "'into' and 'from' are not supported on padding",
                     ));
                 }
 
@@ -606,9 +608,9 @@ fn parse_field(attrs: &[syn::Attribute], ty: &syn::Type, ignore: bool) -> syn::R
     }
 
     // Negative integers need some special handling...
-    if !ignore && ret.class == TypeClass::SInt {
+    if !ignore && class == TypeClass::SInt {
         let bits = ret.bits as u32;
-        let mask: u128 = !0 >> (u128::BITS - bits);
+        let mask: u128 = !0 >> (u128::BITS - ret.bits as u32);
         let mask = syn::LitInt::new(&format!("0x{mask:x}"), Span::mixed_site());
         if ret.into.is_empty() {
             // Bounds check and remove leading ones from negative values
@@ -659,7 +661,6 @@ impl Parse for BitsAttr {
 
                 <Token![=]>::parse(input)?;
 
-
                 if ident == "default" {
                     attr.default = Some(input.parse()?);
                 } else if ident == "into" {
@@ -679,32 +680,6 @@ impl Parse for BitsAttr {
     }
 }
 
-/// Returns the number of bits for a given type
-fn type_bits(ty: &syn::Type) -> (TypeClass, usize) {
-    let syn::Type::Path(syn::TypePath{ path, .. }) = ty else {
-        return (TypeClass::Other, 0);
-    };
-    let Some(ident) = path.get_ident() else {
-        return (TypeClass::Other, 0);
-    };
-    if ident == "bool" {
-        return (TypeClass::Bool, 1);
-    }
-    if ident == "isize" || ident == "usize" {
-        return (TypeClass::UInt, 0); // they have architecture dependend sizes
-    }
-    macro_rules! integer {
-        ($ident:ident => $($uint:ident),* ; $($sint:ident),*) => {
-            match ident {
-                $(_ if ident == stringify!($uint) => (TypeClass::UInt, $uint::BITS as _),)*
-                $(_ if ident == stringify!($sint) => (TypeClass::SInt, $sint::BITS as _),)*
-                _ => (TypeClass::Other, 0)
-            }
-        };
-    }
-    integer!(ident => u8, u16, u32, u64, u128 ; i8, i16, i32, i64, i128)
-}
-
 /// The bitfield macro parameters
 struct Params {
     ty: syn::Type,
@@ -740,6 +715,32 @@ impl Parse for Params {
     }
 }
 
+/// Returns the number of bits for a given type
+fn type_bits(ty: &syn::Type) -> (TypeClass, usize) {
+    let syn::Type::Path(syn::TypePath{ path, .. }) = ty else {
+        return (TypeClass::Other, 0);
+    };
+    let Some(ident) = path.get_ident() else {
+        return (TypeClass::Other, 0);
+    };
+    if ident == "bool" {
+        return (TypeClass::Bool, 1);
+    }
+    if ident == "isize" || ident == "usize" {
+        return (TypeClass::UInt, 0); // they have architecture dependend sizes
+    }
+    macro_rules! integer {
+        ($ident:ident => $($uint:ident),* ; $($sint:ident),*) => {
+            match ident {
+                $(_ if ident == stringify!($uint) => (TypeClass::UInt, $uint::BITS as _),)*
+                $(_ if ident == stringify!($sint) => (TypeClass::SInt, $sint::BITS as _),)*
+                _ => (TypeClass::Other, 0)
+            }
+        };
+    }
+    integer!(ident => u8, u16, u32, u64, u128 ; i8, i16, i32, i64, i128)
+}
+
 #[cfg(test)]
 mod test {
     use quote::quote;

tests/test.rs

@@ -29,7 +29,7 @@ fn members() {
         pub public: usize,
         /// padding
         #[bits(5)]
-        _p: (),
+        __: (),
     }
 
     /// A custom enum
@@ -176,3 +176,65 @@ fn entirely_negative() {
     let v = MyBitfield::new().with_negative(i32::MAX);
     assert_eq!(v.negative(), i32::MAX);
 }
+
+#[test]
+fn defaults() {
+    #[bitfield(u16)]
+    #[derive(PartialEq, Eq)]
+    struct MyBitfield {
+        /// Interpreted as 1-bit flag, with custom default
+        #[bits(default = true)]
+        flag: bool,
+        /// Supports any type, with default/to/from expressions (that are const eval)
+        /// - into/from call #ty::into_bits/#ty::from_bits if nothing else is specified
+        #[bits(13, default = CustomEnum::B, from = CustomEnum::my_from_bits)]
+        custom: CustomEnum,
+        // Padding with default
+        #[bits(2, default = 0b10)]
+        __: (),
+    }
+
+    /// A custom enum
+    #[derive(Debug, PartialEq, Eq)]
+    #[repr(u16)]
+    enum CustomEnum {
+        A = 0,
+        B = 1,
+        C = 2,
+    }
+    impl CustomEnum {
+        // This has to be const eval
+        const fn into_bits(self) -> u16 {
+            self as _
+        }
+        const fn my_from_bits(value: u16) -> Self {
+            match value {
+                0 => Self::A,
+                1 => Self::B,
+                _ => Self::C,
+            }
+        }
+    }
+
+    // Uses defaults
+    let val = MyBitfield::new();
+
+    assert_eq!(val.flag(), true);
+    assert_eq!(val.custom(), CustomEnum::B);
+    assert_eq!(val.0 >> 14, 0b10); // padding
+}
+
+#[test]
+fn default_padding() {
+    #[bitfield(u32)]
+    struct MyBitfield {
+        value: u16,
+        #[bits(15, default = 0xfff)]
+        __: (),
+        #[bits(default = true)]
+        __: bool,
+    }
+    let v = MyBitfield::new().with_value(0xff);
+
+    assert_eq!(v.0, 0x8fff_00ff);
+}