feat: add warnings.

yassun7010 · Jun 20, 2024 · 2c57a6c · 2c57a6c
1 parent a16b444
commit 2c57a6c
Show file tree

Hide file tree

Showing 15 changed files with 155 additions and 85 deletions.
diff --git a/serde_valid_derive/src/attribute/field_validate/field.rs b/serde_valid_derive/src/attribute/field_validate/field.rs
@@ -1,17 +1,23 @@
 use crate::attribute::Validator;
 use crate::types::Field;
+use crate::warning::WithWarnings;
 use quote::quote;
 use std::borrow::Cow;
 use std::iter::FromIterator;
 
 pub struct FieldValidators<'a, F: Field + Clone + 'a> {
     field: Cow<'a, F>,
     validators: Vec<Validator>,
+    pub warnings: Vec<crate::warning::Warning>,
 }
 
 impl<'a, F: Field + Clone> FieldValidators<'a, F> {
-    pub fn new(field: Cow<'a, F>, validators: Vec<Validator>) -> Self {
-        Self { field, validators }
+    pub fn new(field: Cow<'a, F>, validators: Vec<WithWarnings<Validator>>) -> Self {
+        Self {
+            field,
+            validators: validators.iter().map(|v| v.data.clone()).collect(),
+            warnings: validators.into_iter().flat_map(|v| v.warnings).collect(),
+        }
     }
 
     pub fn ident(&self) -> &syn::Ident {

diff --git a/serde_valid_derive/src/attribute/field_validate/generic/validate.rs b/serde_valid_derive/src/attribute/field_validate/generic/validate.rs
@@ -1,19 +1,20 @@
 use crate::attribute::Validator;
 use crate::serde::rename::RenameMap;
 use crate::types::Field;
+use crate::warning::WithWarnings;
 use quote::quote;
 
 pub fn extract_generic_validate_validator(
     field: &impl Field,
     rename_map: &RenameMap,
-) -> Result<Validator, crate::Errors> {
+) -> Result<WithWarnings<Validator>, crate::Errors> {
     let field_ident = field.ident();
     let field_name = field.name();
     let field_key = field.key();
     let rename = rename_map.get(field_name).unwrap_or(&field_key);
     let errors = field.errors_variable();
 
-    Ok(quote!(
+    Ok(WithWarnings::new(quote!(
         if let Err(__inner_errors) = #field_ident.validate() {
             match __inner_errors {
                 ::serde_valid::validation::Errors::Object(__object_errors) => {
@@ -31,5 +32,5 @@ pub fn extract_generic_validate_validator(
                 }
             }
         }
-    ))
+    )))
 }
diff --git a/serde_valid_derive/src/attribute/field_validate/meta.rs b/serde_valid_derive/src/attribute/field_validate/meta.rs
@@ -11,6 +11,7 @@ use crate::attribute::{
 use crate::serde::rename::RenameMap;
 use crate::types::Field;
 use crate::types::SingleIdentPath;
+use crate::warning::WithWarnings;
 use meta_list::extract_field_validator_from_meta_list;
 use meta_name_value::extract_field_validator_from_meta_name_value;
 use meta_path::extract_field_validator_from_meta_path;
@@ -22,7 +23,7 @@ pub fn extract_field_validator(
     field: &impl Field,
     attribute: &syn::Attribute,
     rename_map: &RenameMap,
-) -> Result<Validator, crate::Errors> {
+) -> Result<WithWarnings<Validator>, crate::Errors> {
     match &attribute.meta {
         syn::Meta::List(list) => inner_extract_field_validator(field, attribute, list, rename_map),
         syn::Meta::Path(_) => extract_generic_validate_validator(field, rename_map),
@@ -39,7 +40,7 @@ fn inner_extract_field_validator(
     attribute: &syn::Attribute,
     meta_list: &syn::MetaList,
     rename_map: &RenameMap,
-) -> Result<Validator, crate::Errors> {
+) -> Result<WithWarnings<Validator>, crate::Errors> {
     let mut errors = vec![];
     let nested = meta_list
         .parse_args_with(crate::types::CommaSeparatedMetas::parse_terminated)
@@ -123,6 +124,7 @@ fn inner_extract_field_validator(
                 message_format,
                 rename_map,
             )
+            .map(WithWarnings::new)
         }
 
         (Ok(_), _, _, _) => Err(vec![crate::Error::meta_path_validation_need_value(

diff --git a/serde_valid_derive/src/attribute/field_validate/meta/meta_list.rs b/serde_valid_derive/src/attribute/field_validate/meta/meta_list.rs
@@ -1,28 +1,39 @@
+use syn::spanned::Spanned;
+
 use crate::attribute::common::message_format::MessageFormat;
 use crate::attribute::field_validate::generic::{
     extract_generic_custom_validator, extract_generic_enumerate_validator_from_list,
 };
-use crate::attribute::MetaListFieldValidation;
-use crate::attribute::Validator;
+use crate::attribute::{MetaListFieldValidation, Validator};
 use crate::serde::rename::RenameMap;
 use crate::types::Field;
+use crate::warning::Warning;
+use crate::warning::WithWarnings;
 
 pub fn extract_field_validator_from_meta_list(
     field: &impl Field,
     validation_type: MetaListFieldValidation,
     validation: &syn::MetaList,
     message_format: MessageFormat,
     rename_map: &RenameMap,
-) -> Result<Validator, crate::Errors> {
+) -> Result<WithWarnings<Validator>, crate::Errors> {
     match validation_type {
         MetaListFieldValidation::Enumerate => extract_generic_enumerate_validator_from_list(
             field,
             validation,
             message_format,
             rename_map,
-        ),
+        )
+        .map(|data| WithWarnings {
+            data,
+            warnings: vec![Warning::new_enumerate_path_deprecated(
+                field.ident(),
+                validation.span(),
+            )],
+        }),
         MetaListFieldValidation::Custom => {
             extract_generic_custom_validator(field, validation, message_format, rename_map)
+                .map(WithWarnings::new)
         }
     }
 }
diff --git a/serde_valid_derive/src/attribute/field_validate/meta/meta_path.rs b/serde_valid_derive/src/attribute/field_validate/meta/meta_path.rs
@@ -3,19 +3,18 @@ use crate::attribute::field_validate::array::extract_array_unique_items_validato
 use crate::attribute::{MetaPathFieldValidation, Validator};
 use crate::serde::rename::RenameMap;
 use crate::types::Field;
+use crate::warning::WithWarnings;
 
 pub fn extract_field_validator_from_meta_path(
     field: &impl Field,
     validation_type: MetaPathFieldValidation,
     _validation: &syn::Path,
     message_format: MessageFormat,
     rename_map: &RenameMap,
-) -> Result<Validator, crate::Errors> {
+) -> Result<WithWarnings<Validator>, crate::Errors> {
     match validation_type {
-        MetaPathFieldValidation::UniqueItems => Ok(extract_array_unique_items_validator(
-            field,
-            message_format,
-            rename_map,
+        MetaPathFieldValidation::UniqueItems => Ok(WithWarnings::new(
+            extract_array_unique_items_validator(field, message_format, rename_map),
         )),
     }
 }
diff --git a/serde_valid_derive/src/attribute/rule/named_struct_rule.rs b/serde_valid_derive/src/attribute/rule/named_struct_rule.rs
@@ -5,15 +5,15 @@ use quote::{quote, ToTokens};
 use syn::spanned::Spanned;
 
 use crate::{
-    output_stream::OutputStream,
     types::{CommaSeparatedNestedMetas, CommaSeparatedTokenStreams},
     warning::Warning,
+    warning::WithWarnings,
 };
 
 pub fn collect_rules_from_named_struct(
     ident: &syn::Ident,
     attributes: &[syn::Attribute],
-) -> Result<(HashSet<syn::Ident>, OutputStream), crate::Errors> {
+) -> Result<(HashSet<syn::Ident>, WithWarnings<TokenStream>), crate::Errors> {
     let mut errors = vec![];
 
     let mut rule_fields = HashSet::new();
@@ -50,8 +50,8 @@ pub fn collect_rules_from_named_struct(
     if errors.is_empty() {
         Ok((
             rule_fields,
-            OutputStream {
-                output: TokenStream::from_iter(rules),
+            WithWarnings {
+                data: TokenStream::from_iter(rules),
                 warnings,
             },
         ))

diff --git a/serde_valid_derive/src/attribute/rule/unnamed_struct_rule.rs b/serde_valid_derive/src/attribute/rule/unnamed_struct_rule.rs
@@ -5,15 +5,15 @@ use quote::quote;
 use syn::spanned::Spanned;
 
 use crate::{
-    output_stream::OutputStream,
     types::{CommaSeparatedNestedMetas, CommaSeparatedTokenStreams, NestedMeta},
     warning::Warning,
+    warning::WithWarnings,
 };
 
 pub fn collect_rules_from_unnamed_struct(
     ident: &syn::Ident,
     attributes: &[syn::Attribute],
-) -> Result<(HashSet<syn::Ident>, OutputStream), crate::Errors> {
+) -> Result<(HashSet<syn::Ident>, WithWarnings<TokenStream>), crate::Errors> {
     let mut errors = vec![];
 
     let mut rule_fields = HashSet::new();
@@ -50,8 +50,8 @@ pub fn collect_rules_from_unnamed_struct(
     if errors.is_empty() {
         Ok((
             rule_fields,
-            OutputStream {
-                output: TokenStream::from_iter(rules),
+            WithWarnings {
+                data: TokenStream::from_iter(rules),
                 warnings,
             },
         ))

diff --git a/serde_valid_derive/src/attribute/struct_validate.rs b/serde_valid_derive/src/attribute/struct_validate.rs
@@ -1,13 +1,13 @@
 mod generic;
 mod meta;
 
-use crate::attribute::Validator;
+use crate::{attribute::Validator, warning::WithWarnings};
 
 use self::meta::extract_struct_validator;
 
 pub fn collect_struct_custom_from_named_struct(
     attributes: &[syn::Attribute],
-) -> Result<Validator, crate::Errors> {
+) -> Result<WithWarnings<Vec<Validator>>, crate::Errors> {
     let mut errors = vec![];
 
     let validations = attributes
@@ -28,7 +28,7 @@ pub fn collect_struct_custom_from_named_struct(
         .collect::<Vec<_>>();
 
     if errors.is_empty() {
-        Ok(Validator::from_iter(validations))
+        Ok(WithWarnings::from_iter(validations))
     } else {
         Err(errors)
     }

diff --git a/serde_valid_derive/src/attribute/struct_validate/meta.rs b/serde_valid_derive/src/attribute/struct_validate/meta.rs
@@ -9,6 +9,7 @@ use crate::{
         Validator,
     },
     types::SingleIdentPath,
+    warning::WithWarnings,
 };
 use quote::quote;
 use std::str::FromStr;
@@ -19,10 +20,14 @@ use self::{
     meta_path::extract_struct_validator_from_meta_path,
 };
 
-pub fn extract_struct_validator(attribute: &syn::Attribute) -> Result<Validator, crate::Errors> {
+pub fn extract_struct_validator(
+    attribute: &syn::Attribute,
+) -> Result<WithWarnings<Validator>, crate::Errors> {
     match &attribute.meta {
-        syn::Meta::Path(_) => Ok(quote!()),
-        syn::Meta::List(list) => inner_extract_struct_validator(attribute, list),
+        syn::Meta::Path(_) => Ok(WithWarnings::new(quote!())),
+        syn::Meta::List(list) => {
+            inner_extract_struct_validator(attribute, list).map(WithWarnings::new)
+        }
         syn::Meta::NameValue(name_value) => {
             Err(vec![crate::Error::validate_meta_name_value_not_supported(
                 name_value,

diff --git a/serde_valid_derive/src/derive/enum_derive.rs b/serde_valid_derive/src/derive/enum_derive.rs
@@ -2,10 +2,11 @@ use super::named_struct_derive::collect_named_fields_validators_list;
 use super::unnamed_struct_derive::collect_unnamed_fields_validators_list;
 use crate::attribute::rule::{collect_rules_from_named_struct, collect_rules_from_unnamed_struct};
 use crate::attribute::variant_validate::collect_variant_custom_from_variant;
+use crate::attribute::Validator;
 use crate::error::{array_errors_tokens, new_type_errors_tokens, object_errors_tokens};
-use crate::output_stream::OutputStream;
 use crate::serde::rename::collect_serde_rename_map;
 use crate::types::CommaSeparatedTokenStreams;
+use crate::warning::WithWarnings;
 use proc_macro2::TokenStream;
 use quote::quote;
 use std::collections::HashSet;
@@ -34,7 +35,7 @@ pub fn expand_enum_validate_derive(
                     Ok(variant_varidates_and_rules) => variant_varidates_and_rules,
                     Err(variant_errors) => {
                         errors.extend(variant_errors);
-                        OutputStream::new()
+                        WithWarnings::new(Validator::new())
                     }
                 }
             }
@@ -48,18 +49,18 @@ pub fn expand_enum_validate_derive(
                     Ok(variant_varidates_and_rules) => variant_varidates_and_rules,
                     Err(variant_errors) => {
                         errors.extend(variant_errors);
-                        OutputStream::new()
+                        WithWarnings::new(Validator::new())
                     }
                 }
             }
-            syn::Fields::Unit => OutputStream::new(),
+            syn::Fields::Unit => WithWarnings::new(Validator::new()),
         })
         .collect::<Vec<_>>();
 
     let validations_and_rules = TokenStream::from_iter(
         validations
             .iter()
-            .map(|variant| variant.output.clone())
+            .map(|variant| variant.data.clone())
             .collect::<Vec<_>>(),
     );
     let warnings = validations
@@ -90,7 +91,7 @@ fn expand_enum_variant_named_fields_validation(
     input: &syn::DeriveInput,
     variant: &syn::Variant,
     named_fields: &syn::FieldsNamed,
-) -> Result<OutputStream, crate::Errors> {
+) -> Result<WithWarnings<Validator>, crate::Errors> {
     let mut errors = vec![];
 
     let variant_ident = &variant.ident;
@@ -99,15 +100,15 @@ fn expand_enum_variant_named_fields_validation(
 
     let (
         rule_fields,
-        OutputStream {
-            output: rules,
+        WithWarnings {
+            data: rules,
             warnings,
         },
     ) = match collect_rules_from_named_struct(&variant.ident, &variant.attrs) {
         Ok(field_rules) => field_rules,
         Err(variant_errors) => {
             errors.extend(variant_errors);
-            (HashSet::new(), OutputStream::new())
+            (HashSet::new(), WithWarnings::new(Validator::new()))
         }
     };
 
@@ -146,8 +147,8 @@ fn expand_enum_variant_named_fields_validation(
     let variant_errors = object_errors_tokens();
 
     if errors.is_empty() {
-        Ok(OutputStream {
-            output: quote!(
+        Ok(WithWarnings {
+            data: quote!(
                 if let #ident::#variant_ident{#fields_idents} = &self {
                     let mut __rule_vec_errors = ::serde_valid::validation::VecErrors::new();
                     let mut __property_vec_errors_map = ::serde_valid::validation::PropertyVecErrorsMap::new();
@@ -173,23 +174,23 @@ fn expand_enum_variant_unnamed_fields_varidation(
     input: &syn::DeriveInput,
     variant: &syn::Variant,
     unnamed_fields: &syn::FieldsUnnamed,
-) -> Result<OutputStream, crate::Errors> {
+) -> Result<WithWarnings<Validator>, crate::Errors> {
     let mut errors = vec![];
 
     let variant_ident = &variant.ident;
     let mut fields_idents = CommaSeparatedTokenStreams::new();
 
     let (
         rule_fields,
-        OutputStream {
-            output: rules,
+        WithWarnings {
+            data: rules,
             warnings,
         },
     ) = match collect_rules_from_unnamed_struct(&variant.ident, &variant.attrs) {
         Ok(field_rules) => field_rules,
         Err(variant_errors) => {
             errors.extend(variant_errors);
-            (HashSet::new(), OutputStream::new())
+            (HashSet::new(), WithWarnings::new(Validator::new()))
         }
     };
 
@@ -232,8 +233,8 @@ fn expand_enum_variant_unnamed_fields_varidation(
     };
 
     if errors.is_empty() {
-        Ok(OutputStream {
-            output: quote!(
+        Ok(WithWarnings {
+            data: quote!(
                 if let #ident::#variant_ident(#fields_idents) = &self {
                     let mut __rule_vec_errors = ::serde_valid::validation::VecErrors::new();
                     let mut __item_vec_errors_map = ::serde_valid::validation::ItemVecErrorsMap::new();