Implement deserialize_with for variants

Complements variant serialize_with and closes #1013.

test_suite/tests/compile-fail/with-variant/skip_de_newtype_field.rs

@@ -0,0 +1,25 @@
+// Copyright 2017 Serde Developers
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[macro_use]
+extern crate serde_derive;
+
+#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+//~^ HELP: variant `Newtype` cannot have both #[serde(deserialize_with)] and a field 0 marked with #[serde(skip_deserializing)]
+enum Enum {
+    #[serde(deserialize_with = "deserialize_some_newtype_variant")]
+    Newtype(#[serde(skip_deserializing)] String),
+}
+
+fn deserialize_some_newtype_variant<'de, D>(_: D) -> StdResult<String, D::Error>
+    where D: Deserializer<'de>,
+{
+    unimplemented!()
+}
+
+fn main() { }

test_suite/tests/compile-fail/with-variant/skip_de_struct_field.rs

@@ -0,0 +1,29 @@
+// Copyright 2017 Serde Developers
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[macro_use]
+extern crate serde_derive;
+
+#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+//~^ HELP: variant `Struct` cannot have both #[serde(deserialize_with)] and a field `f1` marked with #[serde(skip_deserializing)]
+enum Enum {
+    #[serde(deserialize_with = "deserialize_some_other_variant")]
+    Struct {
+        #[serde(skip_deserializing)]
+        f1: String,
+        f2: u8,
+    },
+}
+
+fn deserialize_some_other_variant<'de, D>(_: D) -> StdResult<(String, u8), D::Error>
+    where D: Deserializer<'de>,
+{
+    unimplemented!()
+}
+
+fn main() { }

test_suite/tests/compile-fail/with-variant/skip_de_tuple_field.rs

@@ -0,0 +1,25 @@
+// Copyright 2017 Serde Developers
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[macro_use]
+extern crate serde_derive;
+
+#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+//~^ HELP: variant `Tuple` cannot have both #[serde(deserialize_with)] and a field 0 marked with #[serde(skip_deserializing)]
+enum Enum {
+    #[serde(deserialize_with = "deserialize_some_other_variant")]
+    Tuple(#[serde(skip_deserializing)] String, u8),
+}
+
+fn deserialize_some_other_variant<'de, D>(_: D) -> StdResult<(String, u8), D::Error>
+    where D: Deserializer<'de>,
+{
+    unimplemented!()
+}
+
+fn main() { }

test_suite/tests/compile-fail/with-variant/skip_de_whole_variant.rs

@@ -0,0 +1,26 @@
+// Copyright 2017 Serde Developers
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[macro_use]
+extern crate serde_derive;
+
+#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+//~^ HELP: variant `Unit` cannot have both #[serde(deserialize_with)] and #[serde(skip_deserializing)]
+enum Enum {
+    #[serde(deserialize_with = "deserialize_some_unit_variant")]
+    #[serde(skip_deserializing)]
+    Unit,
+}
+
+fn deserialize_some_unit_variant<'de, D>(_: D) -> StdResult<(), D::Error>
+    where D: Deserializer<'de>,
+{
+    unimplemented!()
+}
+
+fn main() { }

test_suite/tests/test_annotations.rs

@@ -11,6 +11,7 @@ extern crate serde_derive;
 
 extern crate serde;
 use self::serde::{Serialize, Serializer, Deserialize, Deserializer};
+use self::serde::de::{self, Unexpected};
 
 extern crate serde_test;
 use self::serde_test::{Token, assert_tokens, assert_ser_tokens, assert_de_tokens,
@@ -811,18 +812,22 @@ fn test_serialize_with_enum() {
     );
 }
 
-#[derive(Debug, PartialEq, Serialize)]
-enum SerializeWithVariant {
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+enum WithVariant {
     #[serde(serialize_with="serialize_unit_variant_as_i8")]
+    #[serde(deserialize_with="deserialize_i8_as_unit_variant")]
     Unit,
 
     #[serde(serialize_with="SerializeWith::serialize_with")]
+    #[serde(deserialize_with="DeserializeWith::deserialize_with")]
     Newtype(i32),
 
-    #[serde(serialize_with="serialize_some_other_variant")]
+    #[serde(serialize_with="serialize_variant_as_string")]
+    #[serde(deserialize_with="deserialize_string_as_variant")]
     Tuple(String, u8),
 
-    #[serde(serialize_with="serialize_some_other_variant")]
+    #[serde(serialize_with="serialize_variant_as_string")]
+    #[serde(deserialize_with="deserialize_string_as_variant")]
     Struct {
         f1: String,
         f2: u8,
@@ -835,45 +840,112 @@ fn serialize_unit_variant_as_i8<S>(serializer: S) -> Result<S::Ok, S::Error>
     serializer.serialize_i8(0)
 }
 
-fn serialize_some_other_variant<S>(f1: &String,
-                                   f2: &u8,
-                                   serializer: S)
-                                   -> Result<S::Ok, S::Error>
+fn deserialize_i8_as_unit_variant<'de, D>(deserializer: D) -> Result<(), D::Error>
+    where D: Deserializer<'de>,
+{
+    let n = i8::deserialize(deserializer)?;
+    match n {
+        0 => Ok(()),
+        _ => Err(de::Error::invalid_value(Unexpected::Signed(n as i64), &"0")),
+    }
+}
+
+fn serialize_variant_as_string<S>(f1: &String,
+                                  f2: &u8,
+                                  serializer: S)
+                                  -> Result<S::Ok, S::Error>
     where S: Serializer,
 {
     serializer.serialize_str(format!("{};{:?}", f1, f2).as_str())
 }
 
+fn deserialize_string_as_variant<'de, D>(deserializer: D) -> Result<(String, u8), D::Error>
+    where D: Deserializer<'de>,
+{
+    let s = String::deserialize(deserializer)?;
+    let mut pieces = s.split(';');
+    let f1 = match pieces.next() {
+        Some(x) => x,
+        None => return Err(de::Error::invalid_length(0, &"2")),
+    };
+    let f2 = match pieces.next() {
+        Some(x) => x,
+        None => return Err(de::Error::invalid_length(1, &"2")),
+    };
+    let f2 = match f2.parse() {
+        Ok(n) => n,
+        Err(_) => {
+            return Err(de::Error::invalid_value(Unexpected::Str(f2), &"an 8-bit signed integer"));
+        }
+    };
+    Ok((f1.into(), f2))
+}
+
 #[test]
 fn test_serialize_with_variant() {
     assert_ser_tokens(
-        &SerializeWithVariant::Unit,
+        &WithVariant::Unit,
         &[
-            Token::NewtypeVariant { name: "SerializeWithVariant", variant: "Unit" },
+            Token::NewtypeVariant { name: "WithVariant", variant: "Unit" },
             Token::I8(0),
         ],
     );
 
     assert_ser_tokens(
-        &SerializeWithVariant::Newtype(123),
+        &WithVariant::Newtype(123),
         &[
-            Token::NewtypeVariant { name: "SerializeWithVariant", variant: "Newtype" },
+            Token::NewtypeVariant { name: "WithVariant", variant: "Newtype" },
             Token::Bool(true),
         ],
     );
 
     assert_ser_tokens(
-        &SerializeWithVariant::Tuple("hello".into(), 0),
+        &WithVariant::Tuple("hello".into(), 0),
         &[
-            Token::NewtypeVariant { name: "SerializeWithVariant", variant: "Tuple" },
+            Token::NewtypeVariant { name: "WithVariant", variant: "Tuple" },
             Token::Str("hello;0"),
         ],
     );
 
     assert_ser_tokens(
-        &SerializeWithVariant::Struct { f1: "world".into(), f2: 1 },
+        &WithVariant::Struct { f1: "world".into(), f2: 1 },
         &[
-            Token::NewtypeVariant { name: "SerializeWithVariant", variant: "Struct" },
+            Token::NewtypeVariant { name: "WithVariant", variant: "Struct" },
+            Token::Str("world;1"),
+        ],
+    );
+}
+
+#[test]
+fn test_deserialize_with_variant() {
+    assert_de_tokens(
+        &WithVariant::Unit,
+        &[
+            Token::NewtypeVariant { name: "WithVariant", variant: "Unit" },
+            Token::I8(0),
+        ],
+    );
+
+    assert_de_tokens(
+        &WithVariant::Newtype(123),
+        &[
+            Token::NewtypeVariant { name: "WithVariant", variant: "Newtype" },
+            Token::Bool(true),
+        ],
+    );
+
+    assert_de_tokens(
+        &WithVariant::Tuple("hello".into(), 0),
+        &[
+            Token::NewtypeVariant { name: "WithVariant", variant: "Tuple" },
+            Token::Str("hello;0"),
+        ],
+    );
+
+    assert_de_tokens(
+        &WithVariant::Struct { f1: "world".into(), f2: 1 },
+        &[
+            Token::NewtypeVariant { name: "WithVariant", variant: "Struct" },
             Token::Str("world;1"),
         ],
     );

test_suite/tests/test_gen.rs

@@ -374,7 +374,7 @@ fn test_gen() {
         s: vis::S,
     }
 
-    #[derive(Serialize)]
+    #[derive(Serialize, Deserialize)]
     enum ExternallyTaggedVariantWith {
         #[allow(dead_code)]
         Normal { f1: String },
@@ -404,7 +404,7 @@ fn test_gen() {
     }
     assert_ser::<ExternallyTaggedVariantWith>();
 
-    #[derive(Serialize)]
+    #[derive(Serialize, Deserialize)]
     #[serde(tag = "t")]
     enum InternallyTaggedVariantWith {
         #[allow(dead_code)]
@@ -430,7 +430,7 @@ fn test_gen() {
     }
     assert_ser::<InternallyTaggedVariantWith>();
 
-    #[derive(Serialize)]
+    #[derive(Serialize, Deserialize)]
     #[serde(tag = "t", content = "c")]
     enum AdjacentlyTaggedVariantWith {
         #[allow(dead_code)]
@@ -461,7 +461,7 @@ fn test_gen() {
     }
     assert_ser::<AdjacentlyTaggedVariantWith>();
 
-    #[derive(Serialize)]
+    #[derive(Serialize, Deserialize)]
     #[serde(untagged)]
     enum UntaggedVariantWith {
         #[allow(dead_code)]