Implement serialize_with for variants

As discussed in #1013, serialize_with functions attached to variants receive an
argument for each inner value contained within the variant. Internally such a
function is wired up to the serializer as if the variant were a newtype variant.

test_suite/tests/compile-fail/with-variant/skip_ser_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(Serialize)] //~ ERROR: proc-macro derive panicked
+//~^ HELP: variant `Newtype` cannot have both #[serde(serialize_with)] and a field 0 marked with #[serde(skip_serializing)]
+enum Enum {
+    #[serde(serialize_with = "serialize_some_newtype_variant")]
+    Newtype(#[serde(skip_serializing)] String),
+}
+
+fn serialize_some_newtype_variant<S>(_: &String) -> StdResult<S::Ok, S::Error>
+    where S: Serializer,
+{
+    unimplemented!()
+}
+
+fn main() { }

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

@@ -0,0 +1,27 @@
+// 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(Serialize)] //~ ERROR: proc-macro derive panicked
+//~^ HELP: variant `Newtype` cannot have both #[serde(serialize_with)] and a field 0 marked with #[serde(skip_serializing_if)]
+enum Enum {
+    #[serde(serialize_with = "serialize_some_newtype_variant")]
+    Newtype(#[serde(skip_serializing_if = "always")] String),
+}
+
+fn serialize_some_newtype_variant<S>(_: &String) -> StdResult<S::Ok, S::Error>
+    where S: Serializer,
+{
+    unimplemented!()
+}
+
+fn always<T>(_: &T) -> bool { true }
+
+fn main() { }

test_suite/tests/compile-fail/with-variant/skip_ser_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(Serialize)] //~ ERROR: proc-macro derive panicked
+//~^ HELP: variant `Struct` cannot have both #[serde(serialize_with)] and a field `f1` marked with #[serde(skip_serializing)]
+enum Enum {
+    #[serde(serialize_with = "serialize_some_other_variant")]
+    Struct {
+        #[serde(skip_serializing)]
+        f1: String,
+        f2: u8,
+    },
+}
+
+fn serialize_some_other_variant<S>(_: &String, _: Option<&u8>, _: S) -> StdResult<S::Ok, S::Error>
+    where S: Serializer,
+{
+    unimplemented!()
+}
+
+fn main() { }

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

@@ -0,0 +1,31 @@
+// 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(Serialize)] //~ ERROR: proc-macro derive panicked
+//~^ HELP: variant `Struct` cannot have both #[serde(serialize_with)] and a field `f1` marked with #[serde(skip_serializing_if)]
+enum Enum {
+    #[serde(serialize_with = "serialize_some_newtype_variant")]
+    Struct {
+        #[serde(skip_serializing_if = "always")]
+        f1: String,
+        f2: u8,
+    },
+}
+
+fn serialize_some_other_variant<S>(_: &String, _: Option<&u8>, _: S) -> StdResult<S::Ok, S::Error>
+    where S: Serializer,
+{
+    unimplemented!()
+}
+
+fn always<T>(_: &T) -> bool { true }
+
+fn main() { }

test_suite/tests/compile-fail/with-variant/skip_ser_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(Serialize)] //~ ERROR: proc-macro derive panicked
+//~^ HELP: variant `Tuple` cannot have both #[serde(serialize_with)] and a field 0 marked with #[serde(skip_serializing)]
+enum Enum {
+    #[serde(serialize_with = "serialize_some_other_variant")]
+    Tuple(#[serde(skip_serializing)] String, u8),
+}
+
+fn serialize_some_other_variant<S>(_: &String, _: Option<&u8>, _: S) -> StdResult<S::Ok, S::Error>
+    where S: Serializer,
+{
+    unimplemented!()
+}
+
+fn main() { }

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

@@ -0,0 +1,27 @@
+// 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(Serialize)] //~ ERROR: proc-macro derive panicked
+//~^ HELP: variant `Tuple` cannot have both #[serde(serialize_with)] and a field 0 marked with #[serde(skip_serializing_if)]
+enum Enum {
+    #[serde(serialize_with = "serialize_some_other_variant")]
+    Tuple(#[serde(skip_serializing_if = "always")] String, u8),
+}
+
+fn serialize_some_other_variant<S>(_: &String, _: Option<&u8>, _: S) -> StdResult<S::Ok, S::Error>
+    where S: Serializer,
+{
+    unimplemented!()
+}
+
+fn always<T>(_: &T) -> bool { true }
+
+fn main() { }

test_suite/tests/compile-fail/with-variant/skip_ser_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(Serialize)] //~ ERROR: proc-macro derive panicked
+//~^ HELP: variant `Unit` cannot have both #[serde(serialize_with)] and #[serde(skip_serializing)]
+enum Enum {
+    #[serde(serialize_with = "serialize_some_unit_variant")]
+    #[serde(skip_serializing)]
+    Unit,
+}
+
+fn serialize_some_unit_variant<S>(_: S) -> StdResult<S::Ok, S::Error>
+    where S: Serializer,
+{
+    unimplemented!()
+}
+
+fn main() { }