Add #[bitmap_attr] attribute macro as alternative syntax

- Implements attribute macro that provides the same functionality as bitmap!
- Both macros now generate identical code
- Added comprehensive tests to ensure compatibility
- Maintains all existing functionality while providing cleaner syntax option

Author: RabbitAlbatross

macros/src/lib.rs

@@ -1,5 +1,8 @@
 use proc_macro::TokenStream;
 use syn::parse_macro_input;
+use syn::DeriveInput;  
+use quote::quote;      
+use quote::ToTokens;  
 
 mod generator;
 mod parser;
@@ -116,6 +119,7 @@ mod parser;
 /// assert_eq!(core::mem::size_of::<Bits>(), 8);
 /// ```
 ///
+
 #[proc_macro]
 pub fn bitmap(input: TokenStream) -> TokenStream {
     let parsed = parse_macro_input!(input as parser::BitmapInput);
@@ -124,3 +128,59 @@ pub fn bitmap(input: TokenStream) -> TokenStream {
         Err(err) => err.to_compile_error().into(),
     }
 }
+
+#[proc_macro_attribute]
+pub fn bitmap_attr(_args: TokenStream, input: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(input as DeriveInput);
+    
+    // Convert the attribute macro input to the existing BitmapInput format
+    let bitmap_input = convert_derive_to_bitmap_input(input);
+    
+    // Use the EXACT SAME expansion logic as the bitmap! macro
+    match generator::expand_bitmap(bitmap_input) {
+        Ok(tokens) => tokens.into(),
+        Err(err) => err.to_compile_error().into(),
+    }
+}
+
+fn convert_derive_to_bitmap_input(input: DeriveInput) -> parser::BitmapInput {
+    let name = input.ident;  // Use 'name' not 'struct_name'
+    
+    // Extract struct fields
+    let syn::Data::Struct(data_struct) = input.data else {
+        panic!("#[bitmap_attr] can only be used on structs");
+    };
+    
+    let syn::Fields::Named(fields_named) = data_struct.fields else {
+        panic!("#[bitmap_attr] struct must have named fields");
+    };
+    
+    // Convert each field to the format expected by the existing parser
+    let fields = fields_named.named.into_iter().map(|field| {
+        let field_name = field.ident.expect("Field must have a name");
+        let field_type = field.ty;
+        
+        // Extract the size from the type (e.g., u1 -> 1, u7 -> 7)
+        let type_str = field_type.to_token_stream().to_string();
+        
+        if !type_str.starts_with("u") {
+            panic!("Field type must be unsigned integer like u1, u2, etc.");
+        }
+        
+        let size: u8 = type_str[1..].parse().expect("Invalid bit width");
+        
+        if size == 0 || size > 128 {
+            panic!("Invalid size for {}, expected u{{1..128}}", type_str);
+        }
+        
+        parser::FieldDef {
+            name: field_name,
+            size,
+        }
+    }).collect();
+    
+    parser::BitmapInput {
+        name,  // Use 'name' not 'struct_name'
+        fields,
+    }
+}

src/lib.rs

@@ -1,8 +1,10 @@
 #![no_std]
 
 pub use macros::bitmap;
+pub use macros::bitmap_attr;  
 pub use traits::*;
 
+
 pub mod traits;
 
 #[test]

tests/compare_macros.rs

@@ -0,0 +1,34 @@
+// tests/compare_macros.rs
+use bitmap::{bitmap, bitmap_attr};
+
+// Function-like macro (original)
+bitmap!(
+    struct OldWay {
+        flag: u1,
+        counter: u7,
+    }
+);
+
+// Attribute macro (new)
+#[bitmap_attr]
+struct NewWay {
+    flag: u1, 
+    counter: u7,
+}
+
+#[test]
+fn test_both_macros_produce_same_api() {
+    let mut old = OldWay(0);
+    let mut new = NewWay(0);
+    
+    // Both should have the same methods
+    old.set_flag(1).set_counter(42);
+    new.set_flag(1).set_counter(42);
+    
+    // Both should produce the same results
+    assert_eq!(old.flag(), new.flag());
+    assert_eq!(old.counter(), new.counter());
+    assert_eq!(*old, *new);
+    
+    println!("Both macros produce identical results!");
+}

tests/test_attr.rs

@@ -0,0 +1,33 @@
+// tests/test_attr.rs
+use bitmap::bitmap_attr;
+
+#[bitmap_attr]
+struct TestBits {
+    flag: u1,
+    counter: u7,
+}
+
+#[test]
+fn test_attribute_macro_creates_correct_api() {
+    let mut bits = TestBits(0);
+    
+    // Test that the macro generated the correct methods
+    bits.set_flag(1);
+    bits.set_counter(42);
+    
+    assert_eq!(bits.flag(), 1);
+    assert_eq!(bits.counter(), 42);
+    
+    // Test the raw value
+    assert_eq!(*bits, 0b10101010); // flag=1 (MSB), counter=42
+    
+    println!("Attribute macro creates correct bitmap API!");
+}
+
+#[test] 
+fn test_attribute_macro_deref_and_into() {
+    let bits = TestBits(0xFF);
+    let raw_value: u8 = bits.into();
+    assert_eq!(raw_value, 0xFF);
+    assert_eq!(*bits, 0xFF);
+}