define empty value for native type

Author: yanganto

struct-patch-derive/src/filler.rs

@@ -1,11 +1,14 @@
 use proc_macro2::{Ident, Span, TokenStream};
 use quote::{quote, ToTokens};
 use std::str::FromStr;
-use syn::{parenthesized, DeriveInput, LitStr, Result, Type};
+use syn::meta::ParseNestedMeta;
+use syn::spanned::Spanned;
+use syn::{parenthesized, DeriveInput, Error, Lit, LitStr, Result, Type};
 
 const FILLER: &str = "filler";
 const ATTRIBUTE: &str = "attribute";
 const EXTENDABLE: &str = "extendable";
+const EMPTY_VALUE: &str = "empty_value";
 
 pub(crate) struct Filler {
     visibility: syn::Visibility,
@@ -16,18 +19,28 @@ pub(crate) struct Filler {
     fields: Vec<Field>,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(PartialEq)]
 enum FillerType {
     Option,
+    /// The type with `Default`, `Extend`, `IntoIterator` and `is_empty` implementations
     Extendable(Ident),
+    /// The type defined a value for empty
+    NativeValue(Lit),
 }
 
 impl FillerType {
     fn inner(&self) -> &Ident {
         if let FillerType::Extendable(ident) = self {
             ident
         } else {
-            panic!("FillerType::Option has no inner indent")
+            panic!("Only FillerType::Extendable has inner indent")
+        }
+    }
+    fn value(&self) -> &Lit {
+        if let FillerType::NativeValue(lit) = self {
+            lit
+        } else {
+            panic!("Only FillerType::NativeValue has value")
         }
     }
 }
@@ -74,6 +87,18 @@ impl Filler {
             .map(|f| f.fty.inner())
             .collect::<Vec<_>>();
 
+        let native_value_field_names = fields
+            .iter()
+            .filter(|f| matches!(f.fty, FillerType::NativeValue(_)))
+            .map(|f| f.ident.as_ref())
+            .collect::<Vec<_>>();
+
+        let native_value_field_values = fields
+            .iter()
+            .filter(|f| matches!(f.fty, FillerType::NativeValue(_)))
+            .map(|f| f.fty.value())
+            .collect::<Vec<_>>();
+
         let mapped_attributes = attributes
             .iter()
             .map(|a| {
@@ -105,6 +130,11 @@ impl Filler {
                             return false
                         }
                     )*
+                    #(
+                        if self.#native_value_field_names != #native_value_field_values {
+                            return false
+                        }
+                    )*
                     true
                 }
             }
@@ -115,6 +145,11 @@ impl Filler {
         let filler_impl = quote! {
             impl #generics struct_patch::traits::Filler< #name #generics > for #struct_name #generics #where_clause  {
                 fn apply(&mut self, filler: #name #generics) {
+                    #(
+                        if self.#native_value_field_names == #native_value_field_values {
+                            self.#native_value_field_names = filler.#native_value_field_names;
+                        }
+                    )*
                     #(
                         if self.#extendable_field_names.is_empty() {
                             self.#extendable_field_names.extend(filler.#extendable_field_names.into_iter());
@@ -133,6 +168,7 @@ impl Filler {
                     #name {
                         #(#option_field_names: None,)*
                         #(#extendable_field_names: #extendable_field_types::default(),)*
+                        #(#native_value_field_names: #native_value_field_values,)*
                     }
                 }
             }
@@ -282,7 +318,24 @@ impl Field {
                     }
                     EXTENDABLE => {
                         // #[filler(extendable)]
-                        fty = Some(FillerType::Extendable(extendable_filler_type(&ty)));
+                        if fty.is_some() {
+                            return Err(meta
+                                .error("The field is already the field of filler, we can't defined more than once"));
+                        }
+                        fty = Some(FillerType::Extendable(none_option_filler_type(&ty)));
+                    }
+                    EMPTY_VALUE => {
+                        // #[filler(empty_value=some value)]
+                        if fty.is_some() {
+                            return Err(meta
+                                .error("The field is already the field of filler, we can't defined more than once"));
+                        }
+                        if let Some(lit) = get_lit(path, &meta)? {
+                            fty = Some(FillerType::NativeValue(lit));
+                        } else {
+                            return Err(meta
+                                .error("empty_value needs a clear value to define empty"));
+                        }
                     }
                     _ => {
                         return Err(meta.error(format_args!(
@@ -342,10 +395,29 @@ fn filler_type(ty: &Type) -> Option<FillerType> {
     None
 }
 
-fn extendable_filler_type(ty: &Type) -> Ident {
+fn none_option_filler_type(ty: &Type) -> Ident {
     if let Type::Path(type_path) = ty {
         type_path.path.segments[0].ident.clone()
     } else {
         panic!("#[filler(extendable)] should use on a type")
     }
 }
+
+fn get_lit(attr_name: String, meta: &ParseNestedMeta) -> syn::Result<Option<syn::Lit>> {
+    let expr: syn::Expr = meta.value()?.parse()?;
+    let mut value = &expr;
+    while let syn::Expr::Group(e) = value {
+        value = &e.expr;
+    }
+    if let syn::Expr::Lit(syn::ExprLit { lit, .. }) = value {
+        Ok(Some(lit.clone()))
+    } else {
+        Err(Error::new(
+            expr.span(),
+            format!(
+                "expected serde {} attribute to be lit: `{} = \"...\"`",
+                attr_name, attr_name
+            ),
+        ))
+    }
+}

struct-patch/examples/filler.rs

@@ -34,7 +34,11 @@ impl WrapVec {
 #[filler(attribute(derive(Debug, Default)))]
 struct Item {
     field_complete: bool,
+    // Will check the field is equal to the value to define the field is empty or not
+    #[filler(empty_value = 0)]
     field_int: usize,
+    // Will check the field is equal to String::default() to define the field is empty or not
+    // #[filler(empty=default)]
     field_string: String,
     maybe_field_int: Option<usize>,
     maybe_field_string: Option<String>,
@@ -81,7 +85,7 @@ fn main() {
 
     assert_eq!(
         format!("{filler:?}"),
-        "ItemFiller { maybe_field_int: Some(7), maybe_field_string: None, list: [], _deque: [], _linked_list: [], _set: {}, _bset: {}, _heap: [], _wrap: WrapVec { inner: [] } }"
+        "ItemFiller { field_int: 0, maybe_field_int: Some(7), maybe_field_string: None, list: [], _deque: [], _linked_list: [], _set: {}, _bset: {}, _heap: [], _wrap: WrapVec { inner: [] } }"
     );
 
     item.apply(filler);
@@ -115,4 +119,14 @@ fn main() {
     filler.list = vec![3, 4];
     item.apply(filler);
     assert_eq!(item.list, vec![1, 2]);
+
+    let mut filler: ItemFiller = Item::new_empty_filler();
+    filler.field_int = 7;
+    item.apply(filler);
+    assert_eq!(item.field_int, 7);
+
+    let mut filler: ItemFiller = Item::new_empty_filler();
+    filler.field_int = 5;
+    item.apply(filler);
+    assert_eq!(item.field_int, 7);
 }