Support #[serde(validate = "function")] for container, compatible with validator crate

serde_derive/src/de.rs

@@ -26,6 +26,7 @@ pub fn expand_derive_deserialize(input: &mut syn::DeriveInput) -> syn::Result<To
     let params = Parameters::new(&cont);
     let (de_impl_generics, _, ty_generics, where_clause) = split_with_de_lifetime(&params);
     let body = Stmts(deserialize_body(&cont, &params));
+    let vaildated_body = validate_body(&cont, body)?;
     let delife = params.borrowed.de_lifetime();
     let serde = cont.attrs.serde_path();
 
@@ -40,7 +41,7 @@ pub fn expand_derive_deserialize(input: &mut syn::DeriveInput) -> syn::Result<To
                     __D: #serde::Deserializer<#delife>,
                 {
                     #used
-                    #body
+                    #vaildated_body
                 }
             }
         }
@@ -54,7 +55,7 @@ pub fn expand_derive_deserialize(input: &mut syn::DeriveInput) -> syn::Result<To
                 where
                     __D: #serde::Deserializer<#delife>,
                 {
-                    #body
+                    #vaildated_body
                 }
 
                 #fn_deserialize_in_place
@@ -273,6 +274,30 @@ fn borrowed_lifetimes(cont: &Container) -> BorrowedLifetimes {
     }
 }
 
+fn validate_body(cont: &Container, body: Stmts) -> syn::Result<TokenStream> {
+    let serde = cont.attrs.serde_path();
+    match (cont.attrs.validate(), cont.attrs.validator()) {
+        (None, false) => Ok(quote! { #body }),
+        (Some(validate), false) => Ok(quote! {
+            let body = { #body }?;
+            #validate(&body).map_err(#serde::de::Error::custom)?;
+            Ok(body)
+        }),
+        (None, true) => Ok(quote! {
+            let body = { #body }?;
+            validator::Validate::validate(&body).map_err(#serde::de::Error::custom)?;
+            Ok(body)
+        }),
+        // If both `validator` and `validate` are defined, error will be reported
+        // on the #[serde(validate = "...")]
+        //                           ^^^^^
+        (Some(validate), true) => Err(syn::Error::new(
+            validate.span(),
+            "can not define both `validator` and `validate`",
+        )),
+    }
+}
+
 fn deserialize_body(cont: &Container, params: &Parameters) -> Fragment {
     if cont.attrs.transparent() {
         deserialize_transparent(cont, params)

serde_derive/src/internals/attr.rs

@@ -169,6 +169,8 @@ pub struct Container {
     remote: Option<syn::Path>,
     identifier: Identifier,
     serde_path: Option<syn::Path>,
+    validate: Option<syn::ExprPath>,
+    validator: bool,
     is_packed: bool,
     /// Error message generated when type can't be deserialized
     expecting: Option<String>,
@@ -256,6 +258,8 @@ impl Container {
         let mut remote = Attr::none(cx, REMOTE);
         let mut field_identifier = BoolAttr::none(cx, FIELD_IDENTIFIER);
         let mut variant_identifier = BoolAttr::none(cx, VARIANT_IDENTIFIER);
+        let mut validate = Attr::none(cx, VALIDATE);
+        let mut validator = BoolAttr::none(cx, VALIDATOR);
         let mut serde_path = Attr::none(cx, CRATE);
         let mut expecting = Attr::none(cx, EXPECTING);
         let mut non_exhaustive = false;
@@ -486,6 +490,14 @@ impl Container {
                     if let Some(path) = parse_lit_into_path(cx, CRATE, &meta)? {
                         serde_path.set(&meta.path, path);
                     }
+                } else if meta.path == VALIDATE {
+                    // #[serde(validate = "...")]
+                    if let Some(path) = parse_lit_into_expr_path(cx, VALIDATE, &meta)? {
+                        validate.set(&meta.path, path);
+                    }
+                } else if meta.path == VALIDATOR {
+                    // #[serde(validator)]
+                    validator.set_true(meta.path);
                 } else if meta.path == EXPECTING {
                     // #[serde(expecting = "a message")]
                     if let Some(s) = get_lit_str(cx, EXPECTING, &meta)? {
@@ -539,6 +551,8 @@ impl Container {
             remote: remote.get(),
             identifier: decide_identifier(cx, item, field_identifier, variant_identifier),
             serde_path: serde_path.get(),
+            validate: validate.get(),
+            validator: validator.get(),
             is_packed,
             expecting: expecting.get(),
             non_exhaustive,
@@ -597,6 +611,14 @@ impl Container {
         self.remote.as_ref()
     }
 
+    pub fn validate(&self) -> Option<&syn::ExprPath> {
+        self.validate.as_ref()
+    }
+
+    pub fn validator(&self) -> bool {
+        self.validator
+    }
+
     pub fn is_packed(&self) -> bool {
         self.is_packed
     }

serde_derive/src/internals/symbol.rs

@@ -38,6 +38,8 @@ pub const TRANSPARENT: Symbol = Symbol("transparent");
 pub const TRY_FROM: Symbol = Symbol("try_from");
 pub const UNTAGGED: Symbol = Symbol("untagged");
 pub const VARIANT_IDENTIFIER: Symbol = Symbol("variant_identifier");
+pub const VALIDATE: Symbol = Symbol("validate");
+pub const VALIDATOR: Symbol = Symbol("validator");
 pub const WITH: Symbol = Symbol("with");
 
 impl PartialEq<Symbol> for Ident {

test_suite/Cargo.toml

@@ -19,3 +19,4 @@ serde = { path = "../serde", features = ["rc"] }
 serde_derive = { path = "../serde_derive", features = ["deserialize_in_place"] }
 serde_test = "1.0.176"
 trybuild = { version = "1.0.97", features = ["diff"] }
+validator = { version = "0.20", features = ["derive"] }

test_suite/tests/test_validate.rs

@@ -0,0 +1,247 @@
+use serde_derive::{Deserialize, Serialize};
+use serde_test::{assert_de_tokens, assert_de_tokens_error, Token};
+use std::fmt::Display;
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[serde(validate = "validate_struct")]
+struct Struct {
+    a: u16,
+}
+
+fn validate_struct(deserialized: &Struct) -> Result<(), impl Display> {
+    if deserialized.a == 0 {
+        return Err("field `a` can not be zero");
+    }
+    Ok(())
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[serde(validate = "validate_tuple_struct")]
+struct TupleStruct(u16);
+
+fn validate_tuple_struct(deserialized: &TupleStruct) -> Result<(), impl Display> {
+    if deserialized.0 == 0 {
+        return Err("field `0` can not be zero");
+    }
+    Ok(())
+}
+
+#[test]
+fn test_struct() {
+    assert_de_tokens(
+        &Struct { a: 1 },
+        &[
+            Token::Struct {
+                name: "Struct",
+                len: 1,
+            },
+            Token::Str("a"),
+            Token::U16(1),
+            Token::StructEnd,
+        ],
+    );
+
+    assert_de_tokens_error::<Struct>(
+        &[
+            Token::Struct {
+                name: "Struct",
+                len: 1,
+            },
+            Token::Str("a"),
+            Token::U16(0),
+            Token::StructEnd,
+        ],
+        "field `a` can not be zero",
+    );
+}
+
+#[test]
+fn test_tuple_struct() {
+    assert_de_tokens(
+        &TupleStruct(1),
+        &[
+            Token::TupleStruct {
+                name: "TupleStruct",
+                len: 1,
+            },
+            Token::U16(1),
+            Token::TupleStructEnd,
+        ],
+    );
+
+    assert_de_tokens_error::<TupleStruct>(
+        &[
+            Token::TupleStruct {
+                name: "TupleStruct",
+                len: 1,
+            },
+            Token::U16(0),
+            Token::TupleStructEnd,
+        ],
+        "field `0` can not be zero",
+    );
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[serde(validate = "validate_struct_variant")]
+enum StructVariant {
+    Struct { a: u16 },
+}
+
+fn validate_struct_variant(deserialized: &StructVariant) -> Result<(), impl Display> {
+    if let StructVariant::Struct { a: 0 } = deserialized {
+        return Err("variant `Struct.a` can not be zero");
+    }
+    Ok(())
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[serde(validate = "validate_tuple_variant")]
+enum TupleVariant {
+    A(u16, u16),
+}
+
+fn validate_tuple_variant(deserialized: &TupleVariant) -> Result<(), impl Display> {
+    if let TupleVariant::A(0, _) = deserialized {
+        return Err("variant `A.0` can not be zero");
+    }
+    Ok(())
+}
+
+#[test]
+fn test_struct_variant() {
+    assert_de_tokens(
+        &StructVariant::Struct { a: 1 },
+        &[
+            Token::StructVariant {
+                name: "StructVariant",
+                variant: "Struct",
+                len: 1,
+            },
+            Token::Str("a"),
+            Token::U16(1),
+            Token::StructVariantEnd,
+        ],
+    );
+
+    assert_de_tokens_error::<StructVariant>(
+        &[
+            Token::StructVariant {
+                name: "StructVariant",
+                variant: "Struct",
+                len: 1,
+            },
+            Token::Str("a"),
+            Token::U16(0),
+            Token::StructVariantEnd,
+        ],
+        "variant `Struct.a` can not be zero",
+    );
+}
+
+#[test]
+fn test_tuple_variant() {
+    assert_de_tokens(
+        &TupleVariant::A(1, 1),
+        &[
+            Token::TupleVariant {
+                name: "TupleVariant",
+                variant: "A",
+                len: 2,
+            },
+            Token::U16(1),
+            Token::U16(1),
+            Token::TupleVariantEnd,
+        ],
+    );
+
+    assert_de_tokens_error::<TupleVariant>(
+        &[
+            Token::TupleVariant {
+                name: "TupleVariant",
+                variant: "A",
+                len: 2,
+            },
+            Token::U16(0),
+            Token::U16(1),
+            Token::TupleVariantEnd,
+        ],
+        "variant `A.0` can not be zero",
+    );
+}
+
+#[derive(Debug, PartialEq, validator::Validate, Deserialize)]
+#[serde(validate = "validator::Validate::validate")]
+struct ValidateStruct {
+    #[validate(email)]
+    mail: String,
+}
+
+#[derive(Debug, PartialEq, validator::Validate, Deserialize)]
+#[serde(validator)]
+struct ValidatorStruct {
+    #[validate(email)]
+    mail: String,
+}
+
+#[test]
+fn test_validate_struct() {
+    assert_de_tokens(
+        &ValidateStruct {
+            mail: "[email protected]".into(),
+        },
+        &[
+            Token::Struct {
+                name: "ValidateStruct",
+                len: 1,
+            },
+            Token::Str("mail"),
+            Token::Str("[email protected]"),
+            Token::StructEnd,
+        ],
+    );
+
+    assert_de_tokens_error::<ValidateStruct>(
+        &[
+            Token::Struct {
+                name: "ValidateStruct",
+                len: 1,
+            },
+            Token::Str("mail"),
+            Token::Str("email.example.com"),
+            Token::StructEnd,
+        ],
+        "mail: Validation error: email [{\"value\": String(\"email.example.com\")}]",
+    );
+}
+
+#[test]
+fn test_validator_struct() {
+    assert_de_tokens(
+        &ValidatorStruct {
+            mail: "[email protected]".into(),
+        },
+        &[
+            Token::Struct {
+                name: "ValidatorStruct",
+                len: 1,
+            },
+            Token::Str("mail"),
+            Token::Str("[email protected]"),
+            Token::StructEnd,
+        ],
+    );
+
+    assert_de_tokens_error::<ValidatorStruct>(
+        &[
+            Token::Struct {
+                name: "ValidatorStruct",
+                len: 1,
+            },
+            Token::Str("mail"),
+            Token::Str("email.example.com"),
+            Token::StructEnd,
+        ],
+        "mail: Validation error: email [{\"value\": String(\"email.example.com\")}]",
+    );
+}

test_suite/tests/ui/validate/both_validator_and_validate.rs

@@ -0,0 +1,11 @@
+use serde_derive::Deserialize;
+
+#[derive(validator::Validate, Deserialize)]
+#[serde(validate = "validator::Validate::validate")]
+#[serde(validator)]
+struct ValidatorStruct {
+    #[validate(email)]
+    mail: String,
+}
+
+fn main() {}

test_suite/tests/ui/validate/both_validator_and_validate.stderr

@@ -0,0 +1,5 @@
+error: can not define both `validator` and `validate`
+ --> tests/ui/validate/both_validator_and_validate.rs:4:20
+  |
+4 | #[serde(validate = "validator::Validate::validate")]
+  |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^