UnexpectedEof error on 0.28.

[BratSinot]

Greeting!

Start getting error on 0.28 version (0.27 work fine).

Here example to reproduce error:
P.S. XmlParser trait needed because I need also json serialization / deserialization.

#[derive(Debug, Deserialize)]
pub struct Foo {
    #[serde(default, rename = "newIDs")]
    pub new_ids: Vec<NewIds>,
}

#[derive(Debug, Deserialize)]
pub struct NewIds {
    #[serde(rename = "$value", deserialize_with = "XmlParser::parse")]
    pub objects: Vec<Bar>,
}

#[derive(Debug)]
pub struct Bar {
    pub id: u32,
    pub num: u32,
}

pub trait XmlParser {
    fn parse<'de, D>(deserializer: D) -> Result<Self, D::Error>
    where
        Self: Sized,
        D: Deserializer<'de>;
}

impl XmlParser for Bar {
    fn parse<'de, D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        #[allow(clippy::enum_variant_names)]
        #[derive(Copy, Clone, Deserialize)]
        enum _Bar {
            One(NewId),
        }

        #[derive(Copy, Clone, Deserialize)]
        struct NewId {
            #[serde(rename = "@newID")]
            id: u32,
        }

        let (id, num) = match _Bar::deserialize(deserializer)? {
            _Bar::One(NewId { id }) => (id, 1),
        };

        Ok(Bar { id, num })
    }
}

impl<T> XmlParser for Vec<T>
where
    T: XmlParser,
{
    fn parse<'de, D>(deserializer: D) -> Result<Self, D::Error>
    where
        Self: Sized,
        D: Deserializer<'de>,
    {
        #[derive(Deserialize)]
        struct _T<T: XmlParser>(#[serde(deserialize_with = "XmlParser::parse")] T);

        let arr = Vec::deserialize(deserializer)?
            .into_iter()
            .map(|_T(t)| t)
            .collect();

        Ok(arr)
    }
}

fn main() -> Result<(), Box<dyn Error>> {
    const XML: &str = r#"<Foo>
            <newIDs>
                <One newID="1"    />
                <One newID="2"    />
            </newIDs>
        </Foo>"#;

    println!("{:?}", from_str::<Foo>(XML)?);

    Ok(())
}

[Mingun]

Thanks for report. I've seen the same error when investigating #567, so probably the cause is the same. It would be wonderful if you'll try to minify your example and do bisect between versions to find the exact commit where the bug was introduced. The history is mostly linear and mostly each commit contains working state, so this shouldn't be too hard.

The error is definitely related to sequence deserialization.

[BratSinot]

It would be wonderful if you'll try to minify your example and do bisect between versions to find the exact commit where the bug was introduced.

It was started after 221b57d.
Previous (b3ebf7a) is OK.

[BratSinot]

About simplifying, this is maximum what I can do:

[package]
name = "playground"
version = "0.1.0"
edition = "2021"

[dependencies]
#OK
#quick-xml = { git = "https://github.com/tafia/quick-xml.git", rev = "b3ebf7a038f3984803589eb19aaaf4e950bf68b3", features = ["serialize", "overlapped-lists"] }
#Not OK
quick-xml = { git = "https://github.com/tafia/quick-xml.git", rev = "221b57d73f9f44060bcf13f49e5868ee13ae1f55", features = ["serialize", "overlapped-lists"] }

use quick_xml::de::from_str;
use serde::{Deserialize, Deserializer};
use std::{error::Error, fmt::Debug};

trait XmlParser {
    fn parse<'de, D>(deserializer: D) -> Result<Self, D::Error>
    where
        Self: Sized,
        D: Deserializer<'de>;
}

#[derive(Debug, Deserialize)]
pub struct Seq {
    #[serde(rename = "$value", deserialize_with = "XmlParser::parse")]
    pub new_ids: Vec<Bar>,
}

#[derive(Debug)]
pub struct Bar {
    pub id: u32,
    pub num: u32,
}

impl XmlParser for Bar {
    fn parse<'de, D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        #[allow(clippy::enum_variant_names)]
        #[derive(Copy, Clone, Deserialize)]
        enum _Bar {
            One(NewId),
            Two(NewId),
        }

        #[derive(Copy, Clone, Deserialize)]
        struct NewId {
            #[serde(rename = "@newID")]
            id: u32,
        }

        let (id, num) = match _Bar::deserialize(deserializer)? {
            _Bar::One(NewId { id }) => (id, 1),
            _Bar::Two(NewId { id }) => (id, 2),
        };

        Ok(Bar { id, num })
    }
}

// TODO: https://github.com/serde-rs/serde/issues/723
impl<T> XmlParser for Vec<T>
where
    T: XmlParser,
{
    fn parse<'de, D>(deserializer: D) -> Result<Self, D::Error>
    where
        Self: Sized,
        D: Deserializer<'de>,
    {
        #[derive(Deserialize)]
        struct _T<T: XmlParser>(#[serde(deserialize_with = "XmlParser::parse")] T);

        let arr = Vec::deserialize(deserializer)?
            .into_iter()
            .map(|_T(t)| t)
            .collect();

        Ok(arr)
    }
}

fn main() -> Result<(), Box<dyn Error>> {
    const XML: &str = r#"
        <Seq>
            <One newID="10" />
            <Two newID="20" />
        </Seq>"#;

    println!("{:?}", from_str::<Seq>(XML)?);

    Ok(())
}

[paramako]

any updates on this?

[BratSinot]

any updates on this?

I just start to use different approach.
I have some XmlStruct which implement structure for quick-xml / serde without deserialize_with and OrdinaryStruct and convert xml to ordinary throught From trait.

[Mingun]

The minimal reproduction case is

/// Regression test for https://github.com/tafia/quick-xml/issues/580.
#[test]
fn issue580() {
    #[derive(Debug, Deserialize, PartialEq, Eq)]
    struct Seq {
        #[serde(rename = "$value")]
        items: Vec<Wrapper>,
    }

    #[derive(Debug, Deserialize, PartialEq, Eq)]
    struct Wrapper(#[serde(deserialize_with = "Item::parse")] Item);

    #[derive(Debug, PartialEq, Eq)]
    struct Item;
    impl Item {
        fn parse<'de, D>(_deserializer: D) -> Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            Ok(Item)
        }
    }

    assert_eq!(
        from_str::<Seq>(
            r#"
        <Seq>
            <One/>
            <Two/>
        </Seq>"#
        )
        .unwrap(),
        Seq {
            items: vec![Wrapper(Item), Wrapper(Item)]
        }
    );
}

If replace vector item type from Wrapper to Item, the bug disappeared