refactor field filtering

Author: panicbit

custom_debug_derive/src/lib.rs

@@ -1,62 +1,58 @@
+use crate::filter_ext::FilterExt;
 use itertools::Itertools;
 use proc_macro2::TokenStream;
 use quote::quote;
 use syn::spanned::Spanned;
 use syn::{parse_str, Fields, Ident, Lit, Meta, NestedMeta, Path, Result};
 use synstructure::{decl_derive, AddBounds, BindingInfo, Structure, VariantInfo};
 
+mod filter_ext;
 #[cfg(test)]
 mod tests;
 
 decl_derive!([Debug, attributes(debug)] => custom_debug_derive);
 
 fn custom_debug_derive(mut structure: Structure) -> Result<TokenStream> {
+    filter_out_skipped_fields(&mut structure)?;
+
     structure.add_bounds(AddBounds::Fields);
 
-    let skip_ident: Ident = parse_str("skip").unwrap();
+    let match_arms =
+        structure.each_variant(|variant| generate_match_arm_body(variant).into_stream());
+
+    Ok(structure.gen_impl(quote! {
+        gen impl ::core::fmt::Debug for @Self {
+            fn fmt(&self, fmt: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+                match self {
+                    #match_arms
+                }
+            }
+        }
+    }))
+}
 
-    let mut filter_err = None;
+fn filter_out_skipped_fields(structure: &mut Structure) -> Result<()> {
+    let skip_ident: Ident = parse_str("skip").unwrap();
 
-    structure.filter(|binding| {
+    structure.try_filter(|binding| {
         for meta in get_metas(binding) {
-            let meta = match meta {
-                Ok(meta) => meta,
-                Err(err) => {
-                    filter_err = Some(err);
-                    return false;
-                }
-            };
+            let meta = meta?;
 
             if let NestedMeta::Meta(Meta::Path(ref path)) = meta {
                 if path
                     .get_ident()
                     .map(|ident| ident == &skip_ident)
                     .unwrap_or(false)
                 {
-                    return false;
+                    return Ok(false);
                 }
             }
         }
 
-        true
-    });
-
-    if let Some(filter_err) = filter_err {
-        return Err(filter_err);
-    }
-
-    let match_arms =
-        structure.each_variant(|variant| generate_match_arm_body(variant).into_stream());
+        Ok(true)
+    })?;
 
-    Ok(structure.gen_impl(quote! {
-        gen impl ::core::fmt::Debug for @Self {
-            fn fmt(&self, fmt: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
-                match self {
-                    #match_arms
-                }
-            }
-        }
-    }))
+    Ok(())
 }
 
 fn generate_match_arm_body(variant: &VariantInfo) -> Result<TokenStream> {