Serde: Regression in serde_codegen

[debris]

version before update: 0.7.4
version after update: 0.7.11

This function

impl Deserialize for Operation {
    fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
        where D: Deserializer {
        let v = try!(Value::deserialize(deserializer));
        if let Value::Object(ref map) = v.clone() {
            if let Some(&Value::String(ref s) = map.get("type") {
                let result = match s.as_ref() {
                    "constructor" => Deserialize::deserialize(&mut value::Deserializer::new(v)).map(Operation::Constructor),
                    "function" => Deserialize::deserialize(&mut value::Deserializer::new(v)).map(Operation::Function),
                    "event" => Deserialize::deserialize(&mut value::Deserializer::new(v)).map(Operation::Event),
                    _ => Err(SerdeError::custom("Invalid operation type.")),
                };

                return result.map_err(|e| D::Error::custom(format!("{:?}", e).as_ref()));
            }
        }
        Err(D::Error::custom("Invalid operation"))
    }
}

used to generate this code in version 0.7.4

    impl Deserialize for Operation {
        fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
         where D: Deserializer {
            let v = try!(Value :: deserialize ( deserializer ));
            if let Value::Object(ref map) = v.clone() {
                if let Some(&Value::String(ref s)) = map.get("type") {
                    let result =
                        match s.as_ref() {
                            "constructor" =>
                            Deserialize::deserialize(&mut value::Deserializer::new(v)).map(Operation::Constructor),
                            "function" =>
                            Deserialize::deserialize(&mut value::Deserializer::new(v)).map(Operation::Function),
                            "event" =>
                            Deserialize::deserialize(&mut value::Deserializer::new(v)).map(Operation::Event),
                            _ =>
                            Err(SerdeError::custom("Invalid operation type.")),
                        };
                    return result.map_err(|e|
                                              D::Error::custom(format!("{:?}"
                                                                       ,
                                                                       e).as_ref()));
                }
            }
            Err(D::Error::custom("Invalid operation"))
        }
    }

0.7.11 generates:

    impl Deserialize for Operation {
        fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
         where D: Deserializer {
            let v = try!(Value :: deserialize ( deserializer ));
            if let Value::Object(ref map) = v.clone() { }
            Err(D::Error::custom("Invalid operation"))
        }
    }

[oli-obk]

this sounds to me like a syntex regression.

have you tried going to 0.7.15 ?

[debris]

have you tried going to 0.7.15 ?

Still broken

[oli-obk]

you are missing a bracket in if let Some(&Value::String(ref s) = map.get("type"), syntex should report an error and not do weird stuff, but still :)

[oli-obk]

I reported this in the syntex repository ( https://github.com/serde-rs/syntex/issues/86 ).

[dtolnay]

This bug is fixed in Syntex 0.42.1. I don't think anyone is urgently waiting for a fix here so I won't bump Serde's Syntex dependency but it will get picked up the next time we bump.