Tracking issue: Unsupported `serde` attributes

[jamesmunns]

CC:

• Feedback request: How to handle unsupported "self-describing-only" attributes serde-rs/serde#2674
• [Bug] Postcard does not handle serde attribute skip_serializing_if properly #122
• #[serde(flatten)] causes serialization to fail #29
• Failing to deserialize  #79
• #[serde(alias)]: see Deserializer::deserialize_struct is incorrect #114 (comment)
• #[serde(tag)]: see More details when WontImplement #259

How to handle this?

[elrafoon]

I'm going to investigate #122.

[samtay]

FYI I also have deserialization issues when using deserialize_with.

[dns2utf8]

I made a PoC for the skipping: #174

[ManevilleF]

It seems that #[serde(skip)] breaks deserialization, due to discriminant offset

pub enum MyEnum {
    A,
    #[serde(skip)]
    B,
    C,
    D,
}

In this case deserializing A would work. But not C. postcard would attempt to deserialize C as D

[jberryman]

Is this still a goal, just not one attained yet?: https://github.com/jamesmunns/postcard/blob/main/README.md?plain=1#L13
Or a fundamental limitation?

I would like to offer an update to the readme to clarify that postcard is not a faster/more compact drop-in replacement for us users of roundtrip serialization via serde_json, but I'm not sure how it should be phrased.

Sadly among the serde-based libraries that are significantly faster and more compact than serde_json, I don't believe that any of them are type-safe as a drop in replacement :(

[jamesmunns]

So, when I wrote that line, it was actually referring to limitations faced in libraries like ssmarshal, which was the major (only?) embedded serde feature format at the time, where you couldn't have enums with more than 255 discriminants, or arrays with more than 255 elements. I actually wasn't referring to the serde modifiers way back then.

That being said, it might deserve a † footnote at this point.

[max-heller]

It seems that #[serde(skip)] breaks deserialization, due to discriminant offset

pub enum MyEnum {
    A,
    #[serde(skip)]
    B,
    C,
    D,
}

In this case deserializing A would work. But not C. postcard would attempt to deserialize C as D

I'm not sure postcard could fix this without a change to serde (see serde-rs/serde#2614).

#[serde(skip)] seems to work with fields already, just not for variants.

[bugadani]

use std::convert::Infallible;

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(try_from = "String")]
pub struct DebugProbeSelector {
    /// The the USB vendor id of the debug probe to be used.
    pub vendor_id: u16,
    /// The the USB product id of the debug probe to be used.
    pub product_id: u16,
    /// The the serial number of the debug probe to be used.
    pub serial_number: Option<String>,
}

impl TryFrom<String> for DebugProbeSelector {
    type Error = Infallible;
    fn try_from(_value: String) -> Result<Self, Self::Error> {
        Ok(DebugProbeSelector {
            vendor_id: 0,
            product_id: 0,
            serial_number: None,
        })
    }
}

pub fn main() {
    let bytes = postcard::to_stdvec(&DebugProbeSelector {
        vendor_id: 0x303a,
        product_id: 0x1001,
        serial_number: Some("DC:DA:0C:D3:FE:D8".to_string()),
    })
    .unwrap();
    postcard::from_bytes::<DebugProbeSelector>(&bytes).unwrap();
}

This panics with DeserializeUnexpectedEnd because of #[serde(try_from = "String")]. I guess this makes sense, and works again by implementing the into part.

[max-heller]

This panics with DeserializeUnexpectedEnd because of #[serde(try_from = "String")]. I guess this makes sense, and works again by implementing the into part.

As you note, this is because of incompatible Serialize and Deserialize implementations, not postcard. Other serialization formats similarly fail on deserialization.

[thautwarm]

How about ignoring serde(tag = "...") for postcard? Postcard itself does not need to be self describing, but it might get used together with other serde backends at one time.
My use case: I use postcard for persistent data storage, while I call some script engine with json format serialized from the same data -- I need serde(tag = "...") for variants in the json case.

[ManevilleF]

@thautwarm you could do one of the following workarounds:

• Custom ser/de impl for either case
• Make ser/de impl of a wrapper type with some settings to define if you need to use tagged enums or not
• Duplicate the structures/enums with From/into impls for one your cases
• Have one serde derive and one facet derive for each case

The simplest option might be to use a serialize_with method where you check if the serializer format is human_readable