Zero copy string array deserialization

[marcoradocchia]

I'm failing to deserialize a TOML array of strings in a zero-copy fashion. I have implemented Deserialize on my custom type, along with its respective Visitor. In the visitor's visit_seq method override I would like to match on seq.next_element::<&str>() without a String allocation, since I don't need to keep it, but rather increment a counter depending on its value and drop it. Sadly, this results in the following error: invalid type: string "...", expected a borrowed string.

Is my approach correct? Am I missing some knowledge? Or is this to be considered a bug?

Example

use serde::{Deserialize, de};

#[derive(Debug, Default, Clone, PartialEq, Eq, Deserialize)]
struct Config {
    values: Values,
}

#[derive(Debug, Default, Clone, PartialEq, Eq)]
struct Values {
    first: usize,
    second: usize,
}

#[derive(Debug)]
struct ValuesVisitor;

impl<'de> de::Visitor<'de> for ValuesVisitor {
    type Value = Values;

    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
        formatter.write_str("either \"first\" or \"second\"")
    }

    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
    where
        A: de::SeqAccess<'de>,
    {
        let mut values = Values::default();

        while let Some(value) = seq.next_element::<&str>()? {
            match value {
                "first" => values.first += 1,
                "second" => values.second += 1,
                _ => return Err(de::Error::invalid_value(de::Unexpected::Str(value), &self)),
            }
        }

        Ok(values)
    }
}

impl<'de> de::Deserialize<'de> for Values {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: de::Deserializer<'de>,
    {
        deserializer.deserialize_seq(ValuesVisitor)
    }
}

fn main() {
    assert_eq!(
        Ok(Config { values: Values { first: 2, second: 1 } }),
        toml::from_str("values = [\"first\", \"second\", \"first\"]"),
    );
}

Output

Executing the above example produces the following output:

thread 'main' (22799) panicked at src/main.rs:53:5:
assertion `left == right` failed
  left: Ok(Config { values: Values { first: 2, second: 1 } })
 right: Err(Error { message: "invalid type: string \"first\", expected a borrowed string", input: Some("values = [\"first\", \"second\", \"first\"]"), keys: ["values"], span: Some(10..17) })
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Opting for owned Strings works as expected, at the cost of an allocation per value:

while let Some(value) = seq.next_element::<String>()? {
    match value.as_str() {
        "first" => values.first += 1,
        "second" => values.second += 1,
        _ => return Err(de::Error::invalid_value(de::Unexpected::Str(&value), &self)),
    }
}

Please note that the illustrated example is not my actual use-case, but rather a minimal gist able to reproduce the issue.

[epage]

I suspect this is #490, see #490 (comment)

[marcoradocchia]

Thank you, I'll have a look!