add support for #[defmt(transparent)]

[vic1707]

Fixes: #934, inspired by https://defmt.ferrous-systems.com/format#newtypes

Here's a proposition implementing a new attribute #[defmt(transparent)] for newtypes and enums (where each variant has only one field).

I tested using

#[derive(defmt::Format)]
#[defmt(transparent)]
struct Unnamed(u8);
#[derive(defmt::Format)]
#[defmt(transparent)]
struct Named {
    foo: u8,
}
#[derive(defmt::Format)]
#[defmt(transparent)]
enum Mixed {
    Unnamed(u8),
    Named { foo: u8 },
    StructUnnamed(Unnamed),
    StructNamed { named: Named },
}

generated code

#[defmt(transparent)]
struct Unnamed(u8);
impl defmt::Format for Unnamed {
    fn format(&self, f: defmt::Formatter) {
        self.0.format(f)
    }
}
#[defmt(transparent)]
struct Named {
    foo: u8,
}
impl defmt::Format for Named {
    fn format(&self, f: defmt::Formatter) {
        self.foo.format(f)
    }
}
#[defmt(transparent)]
enum Mixed {
    Unnamed(u8),
    Named { foo: u8 },
    StructUnnamed(Unnamed),
    StructNamed { named: Named },
}
impl defmt::Format for Mixed {
    fn format(&self, f: defmt::Formatter) {
        match &self {
            Self::Unnamed { 0: inner } => inner.format(f),
            Self::Named { foo: inner } => inner.format(f),
            Self::StructUnnamed { 0: inner } => inner.format(f),
            Self::StructNamed { named: inner } => inner.format(f),
        }
    }
}

Waiting for suggestion's approbation before finishing the PR (docs, changelog, generic super trait requirements etc).

[vic1707]

Just added the support for generic in the derive

tested with

#[derive(Format)]
#[defmt(transparent)]
enum Mixed<T: Clone, U> where U: Clone {
    Unnamed(T),
    Named { foo: u8 },
    StructUnnamed(Unnamed),
    StructNamed { named: U },
}

generated code

impl<T: Clone, U> defmt::Format for Mixed<T, U>
where
    U: Clone,
    T: defmt::Format,
    U: defmt::Format,
{
    fn format(&self, f: defmt::Formatter) {
        match &self {
            Self::Unnamed { 0: inner } => inner.format(f),
            Self::Named { foo: inner } => inner.format(f),
            Self::StructUnnamed { 0: inner } => inner.format(f),
            Self::StructNamed { named: inner } => inner.format(f),
        }
    }
}

---

I also took the liberty to add #[derive(defmt::FormatTransparent)] because I intend to use that feature with auto_enums which doesn't appear to support added attributes.
This is completely selfish and I will understand if you ask me to remove it, I'll just go to auto_enums and try to add support for attributes there.

[jonathanpallant]

I think it makes sense for new-types (struct Thing(u32)) but I don't know that it makes sense for enums, because you're throwing away the discriminant.

[vic1707]

I added it for 2 reasons,

• it was quick & easy, users could want it
• I want to use it in conjunction with auto_enums so I don't care at all about the enum itself 🙃

But the final decision is made by you 👍

[jonathanpallant]

OK, I'm persuaded. Passing to @Urhengulas for a second opinion.

[jonathanpallant]

ping @Veykril on this one