add WriteEnum & rm FieldWriterSafe, add set

Author: burrbull

CHANGELOG.md

@@ -7,6 +7,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+- Add `WriteEnum` constraint for `FieldWriter`s (fix `variant` safety)
+- Make field writer `bits` always `unsafe` add `set` for safe writing
 - Fix bit writer type for `ModifiedWriteValues::ZeroToSet`
 
 ## [v0.32.0] - 2024-02-26

src/generate/generic.rs

@@ -56,6 +56,9 @@ pub trait FieldSpec: Sized {
     type Ux: Copy + PartialEq + From<Self>;
 }
 
+/// Marker for fields with fixed values
+pub trait IsEnum: FieldSpec {}
+
 /// Trait implemented by readable registers to enable the `read` method.
 ///
 /// Registers marked with `Writable` can be also be `modify`'ed.
@@ -474,16 +477,13 @@ pub struct Safe;
 /// You should check that value is allowed to pass to register/field writer marked with this
 pub struct Unsafe;
 
-/// Write field Proxy with unsafe `bits`
-pub type FieldWriter<'a, REG, const WI: u8, FI = u8> = raw::FieldWriter<'a, REG, WI, FI, Unsafe>;
-/// Write field Proxy with safe `bits`
-pub type FieldWriterSafe<'a, REG, const WI: u8, FI = u8> = raw::FieldWriter<'a, REG, WI, FI, Safe>;
+/// Write field Proxy
+pub type FieldWriter<'a, REG, const WI: u8, FI = u8, Safety = Unsafe> = raw::FieldWriter<'a, REG, WI, FI, Safety>;
 
-impl<'a, REG, const WI: u8, FI> FieldWriter<'a, REG, WI, FI>
+impl<'a, REG, const WI: u8, FI, Safety> FieldWriter<'a, REG, WI, FI, Safety>
 where
     REG: Writable + RegisterSpec,
     FI: FieldSpec,
-    REG::Ux: From<FI::Ux>,
 {
     /// Field width
     pub const WIDTH: u8 = WI;
@@ -499,7 +499,14 @@ where
     pub const fn offset(&self) -> u8 {
         self.o
     }
+}
 
+impl<'a, REG, const WI: u8, FI, Safety> FieldWriter<'a, REG, WI, FI, Safety>
+where
+    REG: Writable + RegisterSpec,
+    FI: FieldSpec,
+    REG::Ux: From<FI::Ux>,
+{
     /// Writes raw bits to the field
     ///
     /// # Safety
@@ -511,45 +518,31 @@ where
         self.w.bits |= (REG::Ux::from(value) & REG::Ux::mask::<WI>()) << self.o;
         self.w
     }
-    /// Writes `variant` to the field
-    #[inline(always)]
-    pub fn variant(self, variant: FI) -> &'a mut W<REG> {
-        unsafe { self.bits(FI::Ux::from(variant)) }
-    }
 }
 
-impl<'a, REG, const WI: u8, FI> FieldWriterSafe<'a, REG, WI, FI>
+impl<'a, REG, const WI: u8, FI> FieldWriter<'a, REG, WI, FI, Safe>
 where
     REG: Writable + RegisterSpec,
     FI: FieldSpec,
     REG::Ux: From<FI::Ux>,
 {
-    /// Field width
-    pub const WIDTH: u8 = WI;
-
-    /// Field width
-    #[inline(always)]
-    pub const fn width(&self) -> u8 {
-        WI
-    }
-
-    /// Field offset
-    #[inline(always)]
-    pub const fn offset(&self) -> u8 {
-        self.o
-    }
-
     /// Writes raw bits to the field
     #[inline(always)]
-    pub fn bits(self, value: FI::Ux) -> &'a mut W<REG> {
-        self.w.bits &= !(REG::Ux::mask::<WI>() << self.o);
-        self.w.bits |= (REG::Ux::from(value) & REG::Ux::mask::<WI>()) << self.o;
-        self.w
+    pub fn set(self, value: FI::Ux) -> &'a mut W<REG> {
+        unsafe { self.bits(value) }
     }
+}
+
+impl<'a, REG, const WI: u8, FI, Safety> FieldWriter<'a, REG, WI, FI, Safety>
+where
+    REG: Writable + RegisterSpec,
+    FI: IsEnum,
+    REG::Ux: From<FI::Ux>,
+{
     /// Writes `variant` to the field
     #[inline(always)]
     pub fn variant(self, variant: FI) -> &'a mut W<REG> {
-        self.bits(FI::Ux::from(variant))
+        unsafe { self.bits(FI::Ux::from(variant)) }
     }
 }
 

src/generate/register.rs

@@ -1235,19 +1235,16 @@ pub fn fields(
                             quote! { crate::#wproxy<'a, REG, #value_write_ty> }
                         }
                     } else {
-                        let wproxy = Ident::new(
-                            if unsafety {
-                                "FieldWriter"
-                            } else {
-                                "FieldWriterSafe"
-                            },
-                            span,
-                        );
+                        let wproxy = Ident::new("FieldWriter", span);
                         let width = &unsuffixed(width);
-                        if value_write_ty == "u8" {
+                        if value_write_ty == "u8" && unsafety {
                             quote! { crate::#wproxy<'a, REG, #width> }
-                        } else {
+                        } else if unsafety {
                             quote! { crate::#wproxy<'a, REG, #width, #value_write_ty> }
+                        } else {
+                            let safe_ty =
+                                Ident::new(if unsafety { "Unsafe" } else { "Safe" }, span);
+                            quote! { crate::#wproxy<'a, REG, #width, #value_write_ty, crate::#safe_ty> }
                         }
                     };
                     mod_items.extend(quote! {
@@ -1425,7 +1422,7 @@ impl Variant {
             span,
         );
         let sc = case.sanitize(&ev.name);
-        const INTERNALS: [&str; 4] = ["set_bit", "clear_bit", "bit", "bits"];
+        const INTERNALS: [&str; 6] = ["bit", "bits", "clear_bit", "set", "set_bit", "variant"];
         let sc = Ident::new(
             &(if INTERNALS.contains(&sc.as_ref()) {
                 sc + "_"
@@ -1552,6 +1549,7 @@ fn add_from_variants<'a>(
             impl crate::FieldSpec for #pc {
                 type Ux = #fty;
             }
+            impl crate::IsEnum for #pc {}
         });
     }
 }