bitflags! support

[jonas-schievink]

Currently, using #[derive(Format)] on a bitflags!-generated type results in output that looks like Bitflags { bits: 3564356 }, which isn't very readable.

It would be nice if defmt offered a convenient way to format bitflags the same way as the generated Debug implementation. Doing this efficiently probably requires adding first-class support for bitflags.

[jonas-schievink]

I think the simplest way to do this (in terms of additional API surface) would be to add a bitflags! macro that has the same interface as the one from the bitflags crate, and in fact just forwards its arguments to that (so that any improvements to the bitflags crate are picked up automatically).

That macro would then use some internal magic to also generate an efficient Format impl.

[jonas-schievink]

Ah, this is going to be much more difficult to implement efficiently since bitflags can be arbitrary constants, but a proc macro can't access the final value.

[jonas-schievink]

Removing from the milestone as I don't think this will happen in 0.3

[jonas-schievink]

I still really want this, since nicely-formatted bitflags are incredibly useful. I think one possible way to support this would be to create a static per bitflags constant that stores the corresponding mask, and then reading that back out (somehow) in the decoder. They can be stored in a separate section to not use up any defmt format indices. For example:

defmt::bitflags! {
    pub struct Flags: u8 {
        const LE_LIMITED_DISCOVERABLE = 1 << 0;
        const LE_GENERAL_DISCOVERABLE = 1 << 1;
    }
}

This would create 2 additional statics initialized to 1 << 0 and 1 << 1, respectively. The symbol name would contain the name of the constant, so LE_LIMITED_DISCOVERABLE and LE_GENERAL_DISCOVERABLE. It also has to contain some unique identifier so that multiple bitflags types with the same constant names are supported, but Symbol already handles this.

The decoder would then read the static's initializers out of the binary (which is somewhat tricky, and not something we currently do, but should be implementable), and essentially run bitflags' Debug impl code at runtime: for each const defined for the bitflags type, check if all the bits are set, and if so, print the constant's name.

The runtime encoding of Flags would then be maximally efficient: just its format string index followed by Flags' raw bits.