#[serde(untagged)] no longer works correctly in serde versions 1.0.220 and above

[rxdiscovery]

Hello,

Since I upgraded the serde crate from version 1.0.219 to 1.0.224, the #[serde(untagged)] attribute no longer works.

When I try to deserialize this:

#[derive(Debug, Deserialize, Serialize, Clone, Encode, Decode)]
#[serde(untagged)]
pub enum ConditionValueTypeConfig {
    Single(ConditionValueConfig),
    Multiple(Vec<ConditionValueConfig>),
}

#[derive(Debug, Deserialize, Serialize, Clone, Encode, Decode)]
pub enum ConditionValueConfig {
    String(String),
    Integer(i64),
    Decimal(f64),
    HttpMethod(HttpMethodConfig),
    HttpContentType(ContentTypeConfig),
    HttpStatus(u32),
}

I want to deserialize a RON text like this:

Condition(Method,Eq,HttpMethod(Any))

With serde version 1.0.219 :
OK

With serde version 1.0.220 :
'./conf.ron': 95:99-95:100: data did not match any variant of untagged enum ConditionValueTypeConfig")

With serde version 1.0.224 :
./conf.ron': 95:99-95:100: data did not match any variant of untagged enum ConditionValueTypeConfig")

So the bug has appeared since version 1.0.220

Now have to pin the old version in Cargo.toml.

serde = { version = "=1.0.219", features = ["derive"] }

Thank you in advance for your help.

[rxdiscovery]

The problem comes from the RON crate, which can no longer deserialize untagged with enums since version 1.0.219. Here’s some code to run tests:

use serde::{Deserialize, Serialize};

#[derive(Debug, Deserialize, Serialize, Clone)]
#[serde(untagged)]
pub enum WrapperStruct {
    Single(ValueStruct),
    Multiple(Vec<ValueStruct>),
}

#[derive(Debug, Deserialize, Serialize, Clone)]
pub enum ValueStruct {
    String(String),
    Integer(i64),
    Decimal(f64),
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // ---------------------- JSON
    println!("----------JSON----------");

    // Example 1: a single string value
    let json_single = r#"{"String": "hello"}"#;
    let single: WrapperStruct = serde_json::from_str(json_single)?;
    println!("Single: {:?}", single);

    // Example 2: a single numeric value (integer)
    let json_integer = r#"{"Integer": 42}"#;
    let integer: WrapperStruct = serde_json::from_str(json_integer)?;
    println!("Integer: {:?}", integer);

    // Example 3: multiple values
    let json_multiple = r#"[{"String": "hello"}, {"Integer": 123}, {"Decimal": 45.67}]"#;
    let multiple: WrapperStruct = serde_json::from_str(json_multiple)?;
    println!("Multiple: {:?}", multiple);

    // ---------------------- RON
    println!("----------RON----------");

    // Example 1: a single string value
    let ron_single = r#"String("hello")"#;
    let single: WrapperStruct = ron::from_str(ron_single)?;
    println!("Single: {:?}", single);

    // Example 2: a single integer value
    let ron_integer = r#"Integer(42)"#;
    let integer: WrapperStruct = ron::from_str(ron_integer)?;
    println!("Integer: {:?}", integer);

    // Example 3: multiple values
    let ron_multiple = r#"[String("hello"), Integer(123), Decimal(45.67)]"#;
    let multiple: WrapperStruct = ron::from_str(ron_multiple)?;
    println!("Multiple: {:?}", multiple);

    // Serialization back to RON
    let ron_output = ron::to_string(&multiple)?;
    println!("Serialized to RON: {}", ron_output);

    Ok(())
}

Here is the link to the issue in the RON Git repository, in case someone wants to follow the resolution of this bug :

ron-rs/ron#583

[juntyr]

This is likely a duplicate of ron-rs/ron#581 which will be "fixed" by ron-rs/ron#582 short-term, though #2912 is needed for a long-term solution