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,36 @@ fn borrowed_lifetimes(cont: &Container) -> BorrowedLifetimes {
     }
 }
 
+fn validate_body(cont: &Container, body: Stmts) -> TokenStream {
+    let serde = cont.attrs.serde_path();
+    let mut validations: Vec<TokenStream> = cont
+        .attrs
+        .validate()
+        .iter()
+        .map(|validate| {
+            quote! {
+                #validate(&body).map_err(#serde::de::Error::custom)?;
+            }
+        })
+        .collect();
+    if cont.attrs.validator() {
+        validations.push(
+            quote! {
+                validator::Validate::validate(&body).map_err(#serde::de::Error::custom)?;
+            },
+        );
+    }
+    if validations.is_empty() {
+        quote! { #body }
+    } else {
+        quote! {
+            let body = { #body }?;
+            #(#validations)*
+            Ok(body)
+        }
+    }
+}
+
 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: Vec<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 = VecAttr::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.insert(&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) -> &[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"] }