visit_enum bug

[frederik-uni]

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UserEntity {
    #[serde(flatten)]
    inner: User,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct User {
    pub id: RecordId,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RecordId(Thing);

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Thing {
    /// Table name
    pub tb: String,
    pub id: Id,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum Id {
    A { a: bool },
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UserData {
    pub name: String,
}

#[cfg(test)]
mod tests {
    use crate::{Id, Point, User, UserEntity};
    use serde_content::{Deserializer, Serializer};

    #[test]
    fn bug() {
        let point = UserEntity {
            inner: User {
                id: crate::RecordId(crate::Thing {
                    tb: "todo!(),".to_owned(),
                    id: Id::A { a: true },
                }),
            },
        };

        let serialized = Serializer::new().serialize(&point).unwrap();

        let deserialized: UserEntity = Deserializer::new(serialized).deserialize().unwrap();
    }
}

[Walker-00]

@rushmorem hey any plan on fixing it?

[poborin]

A minimum reproduction scenario would be

#[test]
fn flatten_nested_untagged_enum() {
    #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
    pub struct NewStruct {
        #[serde(flatten)]
        flattened_struct: FlattenedStruct,
    }

    #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
    pub struct FlattenedStruct {
        pub untagged_enum: UntaggedEnum,
    }

    #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
    pub enum UntaggedEnum {
        A { a: bool },
    }

    let new_struct = NewStruct {
        flattened_struct: FlattenedStruct {
            untagged_enum: UntaggedEnum::A { a: true },
        },
    };

    let value = Serializer::new().serialize(&new_struct).unwrap();
    let de_value = Deserializer::new(value).deserialize().unwrap();
    assert_eq!(new_struct, de_value);
}

There is a workaround. Either setting an internal or adjacent tag to the enum or removing #[serde(flatten)] fixes the problem. Find more about enum tags here https://serde.rs/enum-representations.html

Meanwhile, the actual code that rises an issue sits at https://github.com/serde-rs/serde/blob/da3998acfb80a8e4ea60c8cd9caa0dc83f8bb518/serde/src/de/mod.rs#L1671

fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
where
    A: EnumAccess<'de>,
{
    let _ = data;
    Err(Error::invalid_type(Unexpected::Enum, &self))
}

This PR doesn't fix the problem as data doesn't have any associated hint.

I'm not sure how to tackle the problem from here.