🐛 Fix negative int checks

Author: wrenger

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "bitfield-struct"
-version = "0.4.1"
+version = "0.4.2"
 edition = "2021"
 authors = ["Lars Wrenger <lars@wrenger.net>"]
 description = "Procedural macro for bitfields."

Cargo.toml

@@ -442,7 +442,8 @@ impl ToTokens for Member {
             }
         };
 
-        let mask: u128 = !0 >> (u128::BITS as usize - bits);
+        let bits = *bits as u32;
+        let mask: u128 = !0 >> (u128::BITS - bits);
         let mask = syn::LitInt::new(&format!("0x{mask:x}"), Span::mixed_site());
 
         let code = match class {
@@ -466,13 +467,14 @@ impl ToTokens for Member {
                 #doc
                 #[doc = #location]
                 #vis const fn #with_ident(self, value: #ty) -> Self {
-                    debug_assert!(value <= #mask);
+                    #[allow(unused_comparisons)]
+                    debug_assert!(if value >= 0 { value & !#mask == 0 } else { !value & !#mask == 0 }, "value out of bounds");
                     Self(self.0 & !(#mask << #offset) | (value as #base_ty & #mask) << #offset)
                 }
                 #doc
                 #[doc = #location]
                 #vis const fn #ident(&self) -> #ty {
-                    let shift = #ty::BITS as usize - #bits;
+                    let shift = #ty::BITS - #bits;
                     (((self.0 >> #offset) as #ty) << shift) >> shift
                 }
             },
@@ -483,13 +485,14 @@ impl ToTokens for Member {
                 #[doc = #location]
                 #vis fn #with_ident(self, value: #ty) -> Self {
                     let value: #base_ty = value.into();
-                    debug_assert!(value <= #mask);
+                    #[allow(unused_comparisons)]
+                    debug_assert!(if value >= 0 { value & !#mask == 0 } else { !value & !#mask == 0 }, "value out of bounds");
                     Self(self.0 & !(#mask << #offset) | (value & #mask) << #offset)
                 }
                 #doc
                 #[doc = #location]
                 #vis fn #ident(&self) -> #ty {
-                    let shift = #base_ty::BITS as usize - #bits;
+                    let shift = #base_ty::BITS - #bits;
                     (((self.0 >> #offset) << shift) >> shift).into()
                 }
             },

src/lib.rs

@@ -119,3 +119,60 @@ fn debug() {
     let full = Full::new().with_data(123);
     println!("{full:?}");
 }
+
+#[test]
+fn positive() {
+    #[bitfield(u32)]
+    struct MyBitfield {
+        #[bits(3)]
+        positive: u32,
+        #[bits(29)]
+        _p: (),
+    }
+
+    let v = MyBitfield::new().with_positive(0);
+    assert_eq!(v.positive(), 0);
+    let v = MyBitfield::new().with_positive(1);
+    assert_eq!(v.positive(), 1);
+    let v = MyBitfield::new().with_positive(7);
+    assert_eq!(v.positive(), 7);
+}
+
+#[test]
+fn negative() {
+    #[bitfield(u32)]
+    struct MyBitfield {
+        #[bits(3)]
+        negative: i32,
+        #[bits(29)]
+        _p: (),
+    }
+
+    let v = MyBitfield::new().with_negative(-3);
+    assert_eq!(v.negative(), -3);
+    let v = MyBitfield::new().with_negative(0);
+    assert_eq!(v.negative(), 0);
+    let v = MyBitfield::new().with_negative(3);
+    assert_eq!(v.negative(), 3);
+    let v = MyBitfield::new().with_negative(-4);
+    assert_eq!(v.negative(), -4);
+}
+
+#[test]
+fn entirely_negative() {
+    #[bitfield(u32)]
+    struct MyBitfield {
+        negative: i32,
+    }
+
+    let v = MyBitfield::new().with_negative(-3);
+    assert_eq!(v.negative(), -3);
+    let v = MyBitfield::new().with_negative(0);
+    assert_eq!(v.negative(), 0);
+    let v = MyBitfield::new().with_negative(3);
+    assert_eq!(v.negative(), 3);
+    let v = MyBitfield::new().with_negative(i32::MIN);
+    assert_eq!(v.negative(), i32::MIN);
+    let v = MyBitfield::new().with_negative(i32::MAX);
+    assert_eq!(v.negative(), i32::MAX);
+}