The macro_rules treat -1 as not a pattern

[iddm]

I need a enum which is deserialized with serde from number: -1, 0 and 1.
When I try to use enum_number macro from official serde documentation I get this:

error: expected pattern, found `-1`
  --> src/serde_utils.rs:37:32
   |
37 |                             $( $value => Ok($name::$variant), )*
   |                                ^^^^^^

error: aborting due to previous error

The code is very simple:

enum_number!(Change {
    Down = -1,
    None = 0,
    Up = 1,
});

macro_rules! enum_number {
    ($name:ident { $($variant:ident = $value:expr, )* }) => {
        #[allow(missing_docs)]
        #[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd)]
        pub enum $name {
            $($variant = $value,)*
        }

        impl serde::Serialize for $name {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: serde::Serializer
            {
                // Serialize the enum as a i64.
                serializer.serialize_i64(*self as i64)
            }
        }

        impl<'de> serde::Deserialize<'de> for $name {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
                where D: serde::Deserializer<'de>
            {
                struct Visitor;

                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = $name;

                    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                        formatter.write_str("signed 64-bit integer")
                    }

                    fn visit_i64<E>(self, value: i64) -> Result<$name, E>
                        where E: serde::de::Error
                    {
                        // Rust does not come with a simple way of converting a
                        // number to an enum, so use a big `match`.
                        match value {
                            $( $value => Ok($name::$variant), )*
                            _ => Err(E::custom(
                                format!("unknown {} value: {}",
                                stringify!($name), value))),
                        }
                    }
                }

                // Deserialize the enum from a i64.
                deserializer.deserialize_i64(Visitor)
            }
        }
    }
}

If I change -1 to a positive number it compiles okay. I think it is a problem.

[durka]

I think I know how to fix this. But LLVM's building, so we'll find out in a few hours :)

[durka]

PR incoming.