Generate safe bits writers when possible

[newAM]

The 'bits' method of register writers can be safe if:

• there is a single field that covers the entire register
• that field can represent all values

[rust-highfive]

Thanks for the pull request, and welcome! The Rust team is excited to review your changes, and you should hear from @adamgreig (or someone else) soon.

Please see the contribution instructions for more information.

[burrbull]

map(fn).flatten() could be replaced with flat_map(fn)

Explicit deref also unneeded

[newAM]

map(fn).flatten() could be replaced with flat_map(fn)

I think flat_map is only an Iterator method: https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.flat_map

The map/flatten chains are on single Option<T> types to access deeply nested data, I couldn't find a flat_map method for Option<T>.

Explicit deref also unneeded

Done! Good catch.

[burrbull]

I think flat_map is only an Iterator method: https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.flat_map

I missed this is Option. What about and_then?

[adamgreig]

LGTM, @burrbull ?

[burrbull]

LGTM, @burrbull ?

This will not compile.

[burrbull]

LGTM, @burrbull ?

This will not compile.

if register
            .fields
            .as_ref()
            .and_then(|fields| fields.iter().next())
            .and_then(|field| field.write_constraint)
            .and_then(|constraint| match constraint {
                WriteConstraint::Range(range)
                    if range.min == 0 && range.max == 2_u64.pow(rsize) - 1 =>
                {
                    None
                }
                _ => Some(()),
            })
            .is_some()
        {
            mod_items.extend(quote! {
                #[doc = "Writes raw bits to the register."]
                #[inline(always)]
                pub unsafe fn bits(&mut self, bits: #rty) -> &mut Self {
                    self.0.bits(bits);
                    self
                }
            });
        } else {
            mod_items.extend(quote! {
                #[doc = "Writes raw bits to the register."]
                #[inline(always)]
                pub fn bits(&mut self, bits: #rty) -> &mut Self {
                    unsafe { self.0.bits(bits); }
                    self
                }
            });
        }

[thejpster]

I've looked at this twice now and I can't for the life of me work out what's going on here.

If it's just me, then that's ok. But if anyone else is struggling, maybe some comments would be useful, or to break up the big chain into smaller pieces.

But I love the theory, and this will clean up a bunch of code.

[newAM]

LGTM, @burrbull ?

This will not compile.

Can you explain more?

I am testing this with the STM32WL and stm32-rs, I can compile the generated crate with these changes.

Edit: Nevermind, you're right. Something broke.

I missed this is Option. What about and_then?

Good catch, that's much better. Changed.

[burrbull]

Can you explain more?

self.0.bits(bits) is unsafe

[newAM]

Can you explain more?

self.0.bits(bits) is unsafe

Fixed! I forgot a set -e in my bash script that I used for checking this :(

I've looked at this twice now and I can't for the life of me work out what's going on here.

If it's just me, then that's ok. But if anyone else is struggling, maybe some comments would be useful, or to break up the big chain into smaller pieces.

I broke it up to separate the logic of "can the write be safe" and the code generated as a result. Let me know if that helped :)

[burrbull]

bors r+

[bors]

Build succeeded:

• CI