Merge pull request #3034 from dishmaker/dishmaker/serde_derive_less_filter_map

serde_derive: rewrite .iter().filter_map() with less llvm-lines

Author: dtolnay

serde_derive/src/bound.rs

@@ -31,10 +31,11 @@ pub fn with_where_predicates(
     predicates: &[syn::WherePredicate],
 ) -> syn::Generics {
     let mut generics = generics.clone();
-    generics
-        .make_where_clause()
-        .predicates
-        .extend(predicates.iter().cloned());
+    let dst_predicates = &mut generics.make_where_clause().predicates;
+
+    for predicate in predicates {
+        dst_predicates.push(predicate.clone());
+    }
     generics
 }
 
@@ -43,14 +44,17 @@ pub fn with_where_predicates_from_fields(
     generics: &syn::Generics,
     from_field: fn(&attr::Field) -> Option<&[syn::WherePredicate]>,
 ) -> syn::Generics {
-    let predicates = cont
-        .data
-        .all_fields()
-        .filter_map(|field| from_field(&field.attrs))
-        .flat_map(<[syn::WherePredicate]>::to_vec);
-
     let mut generics = generics.clone();
-    generics.make_where_clause().predicates.extend(predicates);
+    let dst_predicates = &mut generics.make_where_clause().predicates;
+
+    for field in cont.data.all_fields() {
+        let Some(predicate_slice) = from_field(&field.attrs) else {
+            continue;
+        };
+        for inner_predicate in predicate_slice {
+            dst_predicates.push(inner_predicate.clone());
+        }
+    }
     generics
 }
 
@@ -65,14 +69,17 @@ pub fn with_where_predicates_from_variants(
             return generics.clone();
         }
     };
-
-    let predicates = variants
-        .iter()
-        .filter_map(|variant| from_variant(&variant.attrs))
-        .flat_map(<[syn::WherePredicate]>::to_vec);
-
     let mut generics = generics.clone();
-    generics.make_where_clause().predicates.extend(predicates);
+    let dst_predicates = &mut generics.make_where_clause().predicates;
+
+    for variant in variants {
+        let Some(predicate_slice) = from_variant(&variant.attrs) else {
+            continue;
+        };
+        for inner_predicate in predicate_slice {
+            dst_predicates.push(inner_predicate.clone());
+        }
+    }
     generics
 }
 
@@ -256,18 +263,18 @@ pub fn with_bound(
     match &cont.data {
         Data::Enum(variants) => {
             for variant in variants {
-                let relevant_fields = variant
-                    .fields
-                    .iter()
-                    .filter(|field| filter(&field.attrs, Some(&variant.attrs)));
-                for field in relevant_fields {
-                    visitor.visit_field(field.original);
+                for field in &variant.fields {
+                    if filter(&field.attrs, Some(&variant.attrs)) {
+                        visitor.visit_field(field.original);
+                    }
                 }
             }
         }
         Data::Struct(_, fields) => {
-            for field in fields.iter().filter(|field| filter(&field.attrs, None)) {
-                visitor.visit_field(field.original);
+            for field in fields {
+                if filter(&field.attrs, None) {
+                    visitor.visit_field(field.original);
+                }
             }
         }
     }

serde_derive/src/de/enum_adjacently.rs

@@ -31,20 +31,19 @@ pub(super) fn deserialize(
 
     let (variants_stmt, variant_visitor) = enum_::prepare_enum_variant_enum(variants);
 
-    let variant_arms: &Vec<_> = &variants
-        .iter()
-        .enumerate()
-        .filter(|&(_, variant)| !variant.attrs.skip_deserializing())
-        .map(|(i, variant)| {
-            let variant_index = field_i(i);
+    let mut variant_arms = Vec::new();
+    for (i, variant) in variants.iter().enumerate() {
+        if variant.attrs.skip_deserializing() {
+            continue;
+        }
+        let variant_index = field_i(i);
 
-            let block = Match(enum_untagged::deserialize_variant(params, variant, cattrs));
+        let block = Match(enum_untagged::deserialize_variant(params, variant, cattrs));
 
-            quote! {
-                __Field::#variant_index => #block
-            }
-        })
-        .collect();
+        variant_arms.push(quote! {
+            __Field::#variant_index => #block
+        });
+    }
 
     let rust_name = params.type_name();
     let expecting = format!("adjacently tagged enum {}", rust_name);
@@ -64,35 +63,35 @@ pub(super) fn deserialize(
         _serde::#private::Err(<__A::Error as _serde::de::Error>::missing_field(#content))
     };
     let mut missing_content_fallthrough = quote!();
-    let missing_content_arms = variants
-        .iter()
-        .enumerate()
-        .filter(|&(_, variant)| !variant.attrs.skip_deserializing())
-        .filter_map(|(i, variant)| {
-            let variant_index = field_i(i);
-            let variant_ident = &variant.ident;
+    let mut missing_content_arms = Vec::new();
+    for (i, variant) in variants.iter().enumerate() {
+        if variant.attrs.skip_deserializing() {
+            continue;
+        }
+        let variant_index = field_i(i);
+        let variant_ident = &variant.ident;
 
-            let arm = match variant.style {
-                Style::Unit => quote! {
-                    _serde::#private::Ok(#this_value::#variant_ident)
-                },
-                Style::Newtype if variant.attrs.deserialize_with().is_none() => {
-                    let span = variant.original.span();
-                    let func = quote_spanned!(span=> _serde::#private::de::missing_field);
-                    quote! {
-                        #func(#content).map(#this_value::#variant_ident)
-                    }
-                }
-                _ => {
-                    missing_content_fallthrough = quote!(_ => #missing_content);
-                    return None;
+        let arm = match variant.style {
+            Style::Unit => quote! {
+                _serde::#private::Ok(#this_value::#variant_ident)
+            },
+            Style::Newtype if variant.attrs.deserialize_with().is_none() => {
+                let span = variant.original.span();
+                let func = quote_spanned!(span=> _serde::#private::de::missing_field);
+                quote! {
+                    #func(#content).map(#this_value::#variant_ident)
                 }
-            };
-            Some(quote! {
-                __Field::#variant_index => #arm,
-            })
-        })
-        .collect::<Vec<_>>();
+            }
+            _ => {
+                missing_content_fallthrough = quote!(_ => #missing_content);
+                continue;
+            }
+        };
+        missing_content_arms.push(quote! {
+            __Field::#variant_index => #arm,
+        });
+    }
+
     if !missing_content_arms.is_empty() {
         missing_content = quote! {
             match __field {

serde_derive/src/pretend.rs

@@ -114,18 +114,18 @@ fn pretend_fields_used_enum(cont: &Container, variants: &[Variant]) -> TokenStre
     let type_ident = &cont.ident;
     let (_, ty_generics, _) = cont.generics.split_for_impl();
 
-    let patterns = variants
-        .iter()
-        .filter_map(|variant| match variant.style {
+    let mut patterns = Vec::new();
+    for variant in variants {
+        match variant.style {
             Style::Struct | Style::Tuple | Style::Newtype => {
                 let variant_ident = &variant.ident;
                 let members = variant.fields.iter().map(|field| &field.member);
                 let placeholders = (0usize..).map(|i| format_ident!("__v{}", i));
-                Some(quote!(#type_ident::#variant_ident { #(#members: #placeholders),* }))
+                patterns.push(quote!(#type_ident::#variant_ident { #(#members: #placeholders),* }))
             }
-            Style::Unit => None,
-        })
-        .collect::<Vec<_>>();
+            Style::Unit => {}
+        }
+    }
 
     let private2 = private;
     quote! {