Custom readers in the `variant` scope && `pad_bits_after` for unit-like enum variants

[Eclypsed]

I'm trying to create a model to represent these 1-bit and 3-bit fields within a byte:

  7   6   5   4   3   2   1   0
+---+---+---+---+---+---+---+---+
| - | D |  Subtype  | -   -   - |
+---+---+---+---+---+---+---+---+

If the D bit is 1, the Subtype bits should be parsed. If the D bit is 0, the Subtype bits hold no meaning and should be skipped over. Currently I have the following enums:

#[derive(Debug, Clone, Copy, PartialEq, Eq, DekuRead)]
#[deku(id_type = "u8", bits = 3)]
pub enum CdrwSubtype {
    #[deku(id = "0b000")]
    Standard,
    #[deku(id = "0b001")]
    HighSpeed,
    #[deku(id = "0b010")]
    UltraSpeed,
    #[deku(id = "0b011")]
    UltraSpeedPlus,
    #[deku(id_pat = "_")]
    Reserved(u8),
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, DekuRead)]
#[deku(id_type = "u8", bits = 1)]
pub enum AtipDiscType {
    #[deku(id = "0")]
    Cdr(#[deku(bits = 3)] u8), // Ideally this would be a unit-like variant
    #[deku(id = "1")]
    Cdrw(CdrwSubtype),
}

This works, but in order to make sure that deku consumes all 4 bits when parsing I have to include a meaningless 3-bit field for the Cdr variant of AtipDiscType. Ideally, the Cdr variant would be able to be written as unit-like. pad_bits_after seems like a logical attribute to enable skipping bits after parsing the id for unit-like variants. Something like:

pub enum AtipDiscType {
    #[deku(id = "0", pad_bits_after = "3")]
    Cdr,
    #[deku(id = "1")]
    Cdrw(CdrwSubtype),
}

I imagine pad_bits_before might not be possible at the variant-level because it would interfere with matching the id, but maybe pad_bits_after is? I'm interested in anyway of skipping bits after after an id to ensure each variant consumes the same amount of bits, or any alternative way of structuring this that is semantically similar.

[Eclypsed]

Just in case anyone else comes across a similar case, this is fairly easy to get around with a custom reader:

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum AtipDiscType {
    Cdr,
    Cdrw(CdrwSubtype),
}

impl<'a> DekuReader<'a> for AtipDiscType {
    fn from_reader_with_ctx<R: std::io::Read + std::io::Seek>(
        reader: &mut Reader<R>,
        _ctx: (),
    ) -> Result<Self, DekuError>
    where
        Self: Sized,
    {
        let id = u8::from_reader_with_ctx(reader, BitSize(1))?;
        let subtype = CdrwSubtype::from_reader_with_ctx(reader, ())?;
        if id == 0 {
            Ok(Self::Cdr)
        } else {
            Ok(Self::Cdrw(subtype))
        }
    }
}

Unfortunately this approach does not derive DekuRead so if you want a DekuContainerRead implementation or anything else generated by the derive macro, you would need to implement it yourself. I also attempted to implement a custom reader just at the variant level. According to the docs the reader & writer attributes should be valid for the variant scope, but I was unable to get around this error:

#[derive(Debug, Clone, PartialEq, Eq, Hash, DekuRead)]
#[deku(id_type = "u8", bits = 1)]
pub enum AtipDiscType {
    #[deku(id = 0, reader = "skip_subtype(deku::reader)")]
    Cdr,
    #[deku(id = 1)]
    Cdrw(CdrwSubtype),
}

// Both of the following attemps resulted in the same error
fn skip_subtype<R: std::io::Read + std::io::Seek>(
    reader: &mut deku::reader::Reader<R>,
) -> Result<(), DekuError> {
    let _subtype = u8::from_reader_with_ctx(reader, BitSize(3))?;
    Ok(())
}

fn skip_subtype<R: std::io::Read + std::io::Seek>(
    reader: &mut deku::reader::Reader<R>,
) -> Result<AtipDiscType, DekuError> {
    let _subtype = u8::from_reader_with_ctx(reader, BitSize(3))?;
    Ok(AtipDiscType::Cdr)
}

4 | #[derive(Debug, Clone, PartialEq, Eq, Hash, DekuRead)]
  |                                             ^^^^^^^^
  |                                             |
  |                                             expected `()`, found `AtipDiscType`
  |                                             this is found to be of type `()`
  |                                             `match` arms have incompatible types