code_ownership 2.2.0 → 2.2.1

data/ext/cargo-vendor/{serde_derive-1.0.228 → serde_derive-1.0.229}/src/bound.rs

@@ -15,7 +15,6 @@ pub fn without_defaults(generics: &syn::Generics) -> syn::Generics {
             .iter()
             .map(|param| match param {
                 syn::GenericParam::Type(param) => syn::GenericParam::Type(syn::TypeParam {
-                    eq_token: None,
                     default: None,
                     ..param.clone()
                 }),
@@ -31,10 +30,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 +43,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 +68,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
 }
 
@@ -146,7 +152,7 @@ pub fn with_bound(
             match ty {
                 #![cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
                 syn::Type::Array(ty) => self.visit_type(&ty.elem),
-                syn::Type::BareFn(ty) => {
+                syn::Type::FnPtr(ty) => {
                     for arg in &ty.inputs {
                         self.visit_type(&arg.ty);
                     }
@@ -209,7 +215,7 @@ pub fn with_bound(
                 }
                 syn::PathArguments::Parenthesized(arguments) => {
                     for argument in &arguments.inputs {
-                        self.visit_type(argument);
+                        self.visit_type(&argument.ty);
                     }
                     self.visit_return_type(&arguments.output);
                 }
@@ -256,57 +262,68 @@ 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);
+                }
             }
         }
     }
 
     let relevant_type_params = visitor.relevant_type_params;
     let associated_type_usage = visitor.associated_type_usage;
-    let new_predicates = generics
-        .type_params()
-        .map(|param| param.ident.clone())
-        .filter(|id| relevant_type_params.contains(id))
-        .map(|id| syn::TypePath {
-            qself: None,
-            path: id.into(),
-        })
-        .chain(associated_type_usage.into_iter().cloned())
-        .map(|bounded_ty| {
-            syn::WherePredicate::Type(syn::PredicateType {
-                lifetimes: None,
-                // the type parameter that is being bounded e.g. T
-                bounded_ty: syn::Type::Path(bounded_ty),
-                colon_token: <Token![:]>::default(),
-                // the bound e.g. Serialize
-                bounds: vec![syn::TypeParamBound::Trait(syn::TraitBound {
+
+    fn make_where_bounded_type(
+        bounded_ty: syn::TypePath,
+        bound: &syn::Path,
+    ) -> syn::WherePredicate {
+        syn::WherePredicate::Type(syn::PredicateType {
+            attrs: Vec::new(),
+            lifetimes: None,
+            // the type parameter that is being bounded e.g. T
+            bounded_ty: syn::Type::Path(bounded_ty),
+            colon_token: <Token![:]>::default(),
+            // the bound e.g. Serialize
+            bounds: {
+                let mut punct = Punctuated::new();
+                punct.push(syn::TypeParamBound::Trait(syn::TraitBound {
                     paren_token: None,
-                    modifier: syn::TraitBoundModifier::None,
                     lifetimes: None,
+                    modifiers: syn::TraitBoundModifiers::default(),
+                    maybe: None,
                     path: bound.clone(),
-                })]
-                .into_iter()
-                .collect(),
-            })
-        });
+                }));
+                punct
+            },
+        })
+    }
 
-    let mut generics = generics.clone();
-    generics
-        .make_where_clause()
-        .predicates
-        .extend(new_predicates);
-    generics
+    let mut dst_generics = generics.clone();
+    let dst_predicates = &mut dst_generics.make_where_clause().predicates;
+    for param in generics.type_params() {
+        let id = &param.ident;
+        if !relevant_type_params.contains(id) {
+            continue;
+        }
+        let bounded_ty = syn::TypePath {
+            attrs: Vec::new(),
+            qself: None,
+            path: id.clone().into(),
+        };
+        dst_predicates.push(make_where_bounded_type(bounded_ty, bound));
+    }
+    for bounded_ty in associated_type_usage {
+        dst_predicates.push(make_where_bounded_type(bounded_ty.clone(), bound));
+    }
+    dst_generics
 }
 
 pub fn with_self_bound(
@@ -319,6 +336,7 @@ pub fn with_self_bound(
         .make_where_clause()
         .predicates
         .push(syn::WherePredicate::Type(syn::PredicateType {
+            attrs: Vec::new(),
             lifetimes: None,
             // the type that is being bounded e.g. MyStruct<'a, T>
             bounded_ty: type_of_item(cont),
@@ -326,8 +344,9 @@ pub fn with_self_bound(
             // the bound e.g. Default
             bounds: vec![syn::TypeParamBound::Trait(syn::TraitBound {
                 paren_token: None,
-                modifier: syn::TraitBoundModifier::None,
                 lifetimes: None,
+                modifiers: syn::TraitBoundModifiers::default(),
+                maybe: None,
                 path: bound.clone(),
             })]
             .into_iter()
@@ -371,6 +390,7 @@ pub fn with_lifetime_bound(generics: &syn::Generics, lifetime: &str) -> syn::Gen
 
 fn type_of_item(cont: &Container) -> syn::Type {
     syn::Type::Path(syn::TypePath {
+        attrs: Vec::new(),
         qself: None,
         path: syn::Path {
             leading_colon: None,
@@ -387,6 +407,7 @@ fn type_of_item(cont: &Container) -> syn::Type {
                             .map(|param| match param {
                                 syn::GenericParam::Type(param) => {
                                     syn::GenericArgument::Type(syn::Type::Path(syn::TypePath {
+                                        attrs: Vec::new(),
                                         qself: None,
                                         path: param.ident.clone().into(),
                                     }))

data/ext/cargo-vendor/{serde_derive-1.0.228 → serde_derive-1.0.229}/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 {
@@ -282,8 +281,8 @@ pub(super) fn deserialize(
                 __A: _serde::de::SeqAccess<#delife>,
             {
                 // Visit the first element - the tag.
-                match _serde::de::SeqAccess::next_element(&mut __seq)? {
-                    _serde::#private::Some(__variant) => {
+                match _serde::de::SeqAccess::next_element(&mut __seq) {
+                    _serde::#private::Ok(_serde::#private::Some(__variant)) => {
                         // Visit the second element - the content.
                         match _serde::de::SeqAccess::next_element_seed(
                             &mut __seq,
@@ -292,18 +291,20 @@ pub(super) fn deserialize(
                                 marker: _serde::#private::PhantomData,
                                 lifetime: _serde::#private::PhantomData,
                             },
-                        )? {
-                            _serde::#private::Some(__ret) => _serde::#private::Ok(__ret),
+                        ) {
+                            _serde::#private::Ok(_serde::#private::Some(__ret)) => _serde::#private::Ok(__ret),
                             // There is no second element.
-                            _serde::#private::None => {
+                            _serde::#private::Ok(_serde::#private::None) => {
                                 _serde::#private::Err(_serde::de::Error::invalid_length(1, &self))
                             }
+                            _serde::#private::Err(__err) => _serde::#private::Err(__err),
                         }
                     }
                     // There is no first element.
-                    _serde::#private::None => {
+                    _serde::#private::Ok(_serde::#private::None) => {
                         _serde::#private::Err(_serde::de::Error::invalid_length(0, &self))
                     }
+                    _serde::#private::Err(__err) => _serde::#private::Err(__err),
                 }
             }
         }

data/ext/cargo-vendor/{serde_derive-1.0.228 → serde_derive-1.0.229}/src/de/enum_externally.rs

@@ -49,7 +49,7 @@ pub(super) fn deserialize(
             ));
 
             quote! {
-                (__Field::#variant_name, __variant) => #block
+                _serde::#private::Ok((__Field::#variant_name, __variant)) => #block
             }
         });
 
@@ -69,8 +69,9 @@ pub(super) fn deserialize(
         }
     } else {
         quote! {
-            match _serde::de::EnumAccess::variant(__data)? {
+            match _serde::de::EnumAccess::variant(__data) {
                 #(#variant_arms)*
+                _serde::#private::Err(__err) => _serde::#private::Err(__err),
             }
         }
     };

data/ext/cargo-vendor/{serde_derive-1.0.228 → serde_derive-1.0.229}/src/de.rs

@@ -26,9 +26,9 @@ pub fn expand_derive_deserialize(input: &mut syn::DeriveInput) -> syn::Result<To
     replace_receiver(input);
 
     let ctxt = Ctxt::new();
-    let cont = match Container::from_ast(&ctxt, input, Derive::Deserialize, &private.ident()) {
-        Some(cont) => cont,
-        None => return Err(ctxt.check().unwrap_err()),
+    let Some(cont) = Container::from_ast(&ctxt, input, Derive::Deserialize, &private.ident())
+    else {
+        return Err(ctxt.check().unwrap_err());
     };
     precondition(&ctxt, &cont);
     ctxt.check()?;
@@ -594,13 +594,16 @@ fn deserialize_seq_in_place(
                     let (wrapper, wrapper_ty) = wrap_deserialize_field_with(params, field.ty, path);
                     quote!({
                         #wrapper
-                        match _serde::de::SeqAccess::next_element::<#wrapper_ty>(&mut __seq)? {
-                            _serde::#private::Some(__wrap) => {
+                        match _serde::de::SeqAccess::next_element::<#wrapper_ty>(&mut __seq) {
+                            _serde::#private::Ok(_serde::#private::Some(__wrap)) => {
                                 self.place.#member = __wrap.value;
                             }
-                            _serde::#private::None => {
+                            _serde::#private::Ok(_serde::#private::None) => {
                                 #value_if_none;
                             }
+                            _serde::#private::Err(__err) => {
+                                return _serde::#private::Err(__err);
+                            }
                         }
                     })
                 }
@@ -652,7 +655,7 @@ struct FieldWithAliases<'a> {
     aliases: &'a BTreeSet<Name>,
 }
 
-fn field_i(i: usize) -> Ident {
+pub(crate) fn field_i(i: usize) -> Ident {
     Ident::new(&format!("__field{}", i), Span::call_site())
 }
 

data/ext/cargo-vendor/{serde_derive-1.0.228 → serde_derive-1.0.229}/src/internals/ast.rs

@@ -202,17 +202,24 @@ fn fields_from_ast<'a>(
     container_default: &attr::Default,
     private: &Ident,
 ) -> Vec<Field<'a>> {
-    fields
-        .iter()
-        .enumerate()
-        .map(|(i, field)| Field {
+    let mut dst_fields = Vec::with_capacity(fields.len());
+    for field in fields {
+        dst_fields.push(Field {
             member: match &field.ident {
                 Some(ident) => syn::Member::Named(ident.clone()),
-                None => syn::Member::Unnamed(i.into()),
+                None => syn::Member::Unnamed(dst_fields.len().into()),
             },
-            attrs: attr::Field::from_ast(cx, i, field, attrs, container_default, private),
+            attrs: attr::Field::from_ast(
+                cx,
+                dst_fields.len(),
+                field,
+                attrs,
+                container_default,
+                private,
+            ),
             ty: &field.ty,
             original: field,
-        })
-        .collect()
+        });
+    }
+    dst_fields
 }

data/ext/cargo-vendor/{serde_derive-1.0.228 → serde_derive-1.0.229}/src/internals/attr.rs

@@ -1185,13 +1185,11 @@ impl Field {
             }
         }
 
-        // Is skip_deserializing, initialize the field to Default::default() unless a
+        // If skip_deserializing, initialize the field to Default::default() unless a
         // different default is specified by `#[serde(default = "...")]` on
         // ourselves or our container (e.g. the struct we are in).
-        if let Default::None = *container_default {
-            if skip_deserializing.0.value.is_some() {
-                default.set_if_none(Default::Default);
-            }
+        if container_default.is_none() && skip_deserializing.0.value.is_some() {
+            default.set_if_none(Default::Default);
         }
 
         let mut borrowed_lifetimes = borrowed_lifetimes.get().unwrap_or_default();
@@ -1459,9 +1457,8 @@ fn parse_lit_into_path(
     attr_name: Symbol,
     meta: &ParseNestedMeta,
 ) -> syn::Result<Option<syn::Path>> {
-    let string = match get_lit_str(cx, attr_name, meta)? {
-        Some(string) => string,
-        None => return Ok(None),
+    let Some(string) = get_lit_str(cx, attr_name, meta)? else {
+        return Ok(None);
     };
 
     Ok(match string.parse() {
@@ -1481,9 +1478,8 @@ fn parse_lit_into_expr_path(
     attr_name: Symbol,
     meta: &ParseNestedMeta,
 ) -> syn::Result<Option<syn::ExprPath>> {
-    let string = match get_lit_str(cx, attr_name, meta)? {
-        Some(string) => string,
-        None => return Ok(None),
+    let Some(string) = get_lit_str(cx, attr_name, meta)? else {
+        return Ok(None);
     };
 
     Ok(match string.parse() {
@@ -1504,9 +1500,8 @@ fn parse_lit_into_where(
     meta_item_name: Symbol,
     meta: &ParseNestedMeta,
 ) -> syn::Result<Vec<syn::WherePredicate>> {
-    let string = match get_lit_str2(cx, attr_name, meta_item_name, meta)? {
-        Some(string) => string,
-        None => return Ok(Vec::new()),
+    let Some(string) = get_lit_str2(cx, attr_name, meta_item_name, meta)? else {
+        return Ok(Vec::new());
     };
 
     Ok(
@@ -1525,9 +1520,8 @@ fn parse_lit_into_ty(
     attr_name: Symbol,
     meta: &ParseNestedMeta,
 ) -> syn::Result<Option<syn::Type>> {
-    let string = match get_lit_str(cx, attr_name, meta)? {
-        Some(string) => string,
-        None => return Ok(None),
+    let Some(string) = get_lit_str(cx, attr_name, meta)? else {
+        return Ok(None);
     };
 
     Ok(match string.parse() {
@@ -1548,9 +1542,8 @@ fn parse_lit_into_lifetimes(
     cx: &Ctxt,
     meta: &ParseNestedMeta,
 ) -> syn::Result<BTreeSet<syn::Lifetime>> {
-    let string = match get_lit_str(cx, BORROW, meta)? {
-        Some(string) => string,
-        None => return Ok(BTreeSet::new()),
+    let Some(string) = get_lit_str(cx, BORROW, meta)? else {
+        return Ok(BTreeSet::new());
     };
 
     if let Ok(lifetimes) = string.parse_with(|input: ParseStream| {
@@ -1620,11 +1613,8 @@ fn is_cow(ty: &syn::Type, elem: fn(&syn::Type) -> bool) -> bool {
             return false;
         }
     };
-    let seg = match path.segments.last() {
-        Some(seg) => seg,
-        None => {
-            return false;
-        }
+    let Some(seg) = path.segments.last() else {
+        return false;
     };
     let args = match &seg.arguments {
         syn::PathArguments::AngleBracketed(bracketed) => &bracketed.args,
@@ -1647,11 +1637,8 @@ fn is_option(ty: &syn::Type, elem: fn(&syn::Type) -> bool) -> bool {
             return false;
         }
     };
-    let seg = match path.segments.last() {
-        Some(seg) => seg,
-        None => {
-            return false;
-        }
+    let Some(seg) = path.segments.last() else {
+        return false;
     };
     let args = match &seg.arguments {
         syn::PathArguments::AngleBracketed(bracketed) => &bracketed.args,
@@ -1798,7 +1785,7 @@ fn collect_lifetimes(ty: &syn::Type, out: &mut BTreeSet<syn::Lifetime>) {
         syn::Type::Macro(ty) => {
             collect_lifetimes_from_tokens(ty.mac.tokens.clone(), out);
         }
-        syn::Type::BareFn(_)
+        syn::Type::FnPtr(_)
         | syn::Type::Never(_)
         | syn::Type::TraitObject(_)
         | syn::Type::ImplTrait(_)

data/ext/cargo-vendor/{serde_derive-1.0.228 → serde_derive-1.0.229}/src/internals/ctxt.rs

@@ -25,7 +25,7 @@ impl Ctxt {
         }
     }
 
-    /// Add an error to the context object with a tokenenizable object.
+    /// Add an error to the context object with a tokenizable object.
     ///
     /// The object is used for spanning in error messages.
     pub fn error_spanned_by<A: ToTokens, T: Display>(&self, obj: A, msg: T) {
@@ -46,9 +46,8 @@ impl Ctxt {
     pub fn check(self) -> syn::Result<()> {
         let mut errors = self.errors.borrow_mut().take().unwrap().into_iter();
 
-        let mut combined = match errors.next() {
-            Some(first) => first,
-            None => return Ok(()),
+        let Some(mut combined) = errors.next() else {
+            return Ok(());
         };
 
         for rest in errors {

data/ext/cargo-vendor/{serde_derive-1.0.228 → serde_derive-1.0.229}/src/internals/receiver.rs

@@ -111,7 +111,7 @@ impl ReplaceReceiver<'_> {
                 self.visit_type_mut(&mut ty.elem);
                 self.visit_expr_mut(&mut ty.len);
             }
-            Type::BareFn(ty) => {
+            Type::FnPtr(ty) => {
                 for arg in &mut ty.inputs {
                     self.visit_type_mut(&mut arg.ty);
                 }
@@ -190,7 +190,7 @@ impl ReplaceReceiver<'_> {
             }
             PathArguments::Parenthesized(arguments) => {
                 for argument in &mut arguments.inputs {
-                    self.visit_type_mut(argument);
+                    self.visit_type_mut(&mut argument.ty);
                 }
                 self.visit_return_type_mut(&mut arguments.output);
             }

data/ext/cargo-vendor/{serde_derive-1.0.228 → serde_derive-1.0.229}/src/lib.rs

@@ -13,7 +13,7 @@
 //!
 //! [https://serde.rs/derive.html]: https://serde.rs/derive.html
 
-#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.228")]
+#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.229")]
 #![cfg_attr(not(check_cfg), allow(unexpected_cfgs))]
 // Ignored clippy lints
 #![allow(

data/ext/cargo-vendor/{serde_derive-1.0.228 → serde_derive-1.0.229}/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! {