allow value field names

bitbybit/src/bitfield/codegen.rs

@@ -459,7 +459,14 @@ pub fn make_builder(
         .filter(|def| def.setter_type.is_some());
     let params = definitions
         .clone()
-        .map(|def| syn::parse_str::<Ident>(format!("{}", def.field_name).as_str()).unwrap())
+        .map(|def| {
+            // Special handling for reserved identifiers prefix.
+            let mut field_name = def.field_name.to_string();
+            if field_name.starts_with("r#") {
+                field_name = field_name.strip_prefix("r#").unwrap().to_string();
+            }
+            syn::parse_str::<Ident>(&format!("__{}", field_name.to_uppercase())).unwrap()
+        })
         .map(|name| quote! { const #name: bool })
         .collect::<Vec<_>>();
 
@@ -545,19 +552,24 @@ pub fn make_builder(
                         result.push(quote!(false));
                         any_overlaps = true;
                     } else {
-                        let name = syn::parse_str::<Ident>(format!("{}", def.field_name).as_str())
-                            .unwrap();
-                        params.push(quote! { const #name: bool });
-                        names.push(quote!({ #name }));
-                        result.push(quote!({ #name }));
+                        // Special handling for reserved identifiers prefix.
+                        let mut field_name = def.field_name.to_string();
+                        if field_name.starts_with("r#") {
+                            field_name = field_name.strip_prefix("r#").unwrap().to_string();
+                        }
+                        let const_generics =
+                            syn::parse_str::<Ident>(&format!("__{}", field_name.to_uppercase()))
+                                .unwrap();
+                        params.push(quote! { const #const_generics: bool });
+                        names.push(quote!({ #const_generics }));
+                        result.push(quote!({ #const_generics }));
                     }
                 }
             }
             set_params.insert(builder_params);
 
             let doc_comment = &field_definition.doc_comment;
             new_with_builder_chain.push(quote! {
-                #[allow(non_camel_case_types)]
                 impl<#( #params, )*> #builder_struct_name<#( #names, )*> {
                     #(#doc_comment)*
                     pub const fn #with_name(&self, value: #argument_type) -> #builder_struct_name<#( #result, )*> {

bitbybit/tests/builder_value_field.rs

@@ -0,0 +1,10 @@
+// No issues with the private internal field value when a field is named value.
+#[bitbybit::bitfield(u32, default = 0x0, debug)]
+pub struct Data {
+    #[bit(15, rw)]
+    dparity: bool,
+    #[bits(0..=7, rw)]
+    value: u8,
+}
+
+pub fn main() {}

bitbybit/tests/no_compile/invalid_field_range.stderr

@@ -14,7 +14,7 @@ error[E0599]: no method named `with_c` found for struct `PartialTest<true, true,
    |                                                           ^^^^^^ method not found in `PartialTest<true, true, false>`
    |
    = note: the method was found for
-           - `PartialTest<false, b, false>`
+           - `PartialTest<false, __B, false>`
 help: one of the expressions' fields has a method of the same name
    |
 30 |     Test::builder().with_a(u4::new(1)).with_b(u4::new(1)).value.with_c(true).build();

bitbybit/tests/no_compile/missing_fields_in_builder.stderr

@@ -32,7 +32,7 @@ error[E0599]: no method named `with_bar` found for struct `PartialTest<true, tru
    |                                             ^^^^^^^^ method not found in `PartialTest<true, true>`
    |
    = note: the method was found for
-           - `PartialTest<foo, false>`
+           - `PartialTest<__FOO, false>`
 help: one of the expressions' fields has a method of the same name
    |
 15 |     Test::builder().with_bar(1).with_foo(1).value.with_bar(2).build();

bitbybit/tests/no_compile/overlapping_bitfield_u8_fields.stderr

@@ -34,7 +34,7 @@ error[E0599]: no method named `with_a` found for struct `PartialTestAllowed<true
    |                                                                           ^^^^^^ method not found in `PartialTestAllowed<true, true, false, false, false>`
    |
    = note: the method was found for
-           - `PartialTestAllowed<upper, false, c, b, false>`
+           - `PartialTestAllowed<__UPPER, false, __C, __B, false>`
 help: one of the expressions' fields has a method of the same name
    |
 48 |     TestAllowed::builder().with_upper(u4::new(0)).with_lower(u12::new(0)).value.with_a(u2::new(0)).build();

bitbybit/tests/tests.rs

@@ -6,6 +6,7 @@ fn all_tests() {
     t.pass("tests/basic.rs");
     t.pass("tests/with_fields.rs");
     t.pass("tests/correct.rs");
+    t.pass("tests/builder_value_field.rs");
 
     t.compile_fail("tests/no_compile/exhaustive_bitenum.rs");
     t.compile_fail("tests/no_compile/non_exhaustive_bitenum.rs");