From 098da70a7e7b944ceaa032b60a57f5cbe856981f Mon Sep 17 00:00:00 2001
From: dishmaker <141624503+dishmaker@users.noreply.github.com>
Date: Fri, 13 Feb 2026 11:53:04 +0100
Subject: [PATCH] serde_derive: reduce llvm-lines in ser.rs, reuse fn field_i

---
 serde_derive/src/de.rs  |  2 +-
 serde_derive/src/ser.rs | 87 ++++++++++++++++++++---------------------
 2 files changed, 44 insertions(+), 45 deletions(-)

diff --git a/serde_derive/src/de.rs b/serde_derive/src/de.rs
index 38408e9f..e7b8579d 100644
--- a/serde_derive/src/de.rs
+++ b/serde_derive/src/de.rs
@@ -655,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())
 }
 
diff --git a/serde_derive/src/ser.rs b/serde_derive/src/ser.rs
index 6cec87cf..6bc78111 100644
--- a/serde_derive/src/ser.rs
+++ b/serde_derive/src/ser.rs
@@ -1,3 +1,4 @@
+use crate::de::field_i;
 use crate::deprecated::allow_deprecated;
 use crate::fragment::{Fragment, Match, Stmts};
 use crate::internals::ast::{Container, Data, Field, Style, Variant};
@@ -457,8 +458,7 @@ fn serialize_variant(
                 }
             }
             Style::Tuple => {
-                let field_names = (0..variant.fields.len())
-                    .map(|i| Ident::new(&format!("__field{}", i), Span::call_site()));
+                let field_names = (0..variant.fields.len()).map(|i| field_i(i));
                 quote! {
                     #this_value::#variant_ident(#(ref #field_names),*)
                 }
@@ -713,9 +713,9 @@ fn serialize_adjacently_tagged_variant(
                 unreachable!()
             }
         }
-        Style::Newtype => vec![Member::Named(Ident::new("__field0", Span::call_site()))],
+        Style::Newtype => vec![Member::Named(field_i(0))],
         Style::Tuple => (0..variant.fields.len())
-            .map(|i| Member::Named(Ident::new(&format!("__field{}", i), Span::call_site())))
+            .map(|i| Member::Named(field_i(i)))
             .collect(),
         Style::Struct => variant.fields.iter().map(|f| f.member.clone()).collect(),
     };
@@ -834,7 +834,7 @@ fn serialize_tuple_variant(
         .map(|(i, field)| match field.attrs.skip_serializing_if() {
             None => quote!(1),
             Some(path) => {
-                let field_expr = Ident::new(&format!("__field{}", i), Span::call_site());
+                let field_expr = field_i(i);
                 quote!(if #path(#field_expr) { 0 } else { 1 })
             }
         })
@@ -1059,46 +1059,47 @@ fn serialize_tuple_struct_visitor(
     is_enum: bool,
     tuple_trait: &TupleTrait,
 ) -> Vec<TokenStream> {
-    fields
-        .iter()
-        .enumerate()
-        .filter(|(_, field)| !field.attrs.skip_serializing())
-        .map(|(i, field)| {
-            let mut field_expr = if is_enum {
-                let id = Ident::new(&format!("__field{}", i), Span::call_site());
-                quote!(#id)
-            } else {
-                get_member(
-                    params,
-                    field,
-                    &Member::Unnamed(Index {
-                        index: i as u32,
-                        span: Span::call_site(),
-                    }),
-                )
-            };
+    let mut dst_fields = Vec::new();
 
-            let skip = field
-                .attrs
-                .skip_serializing_if()
-                .map(|path| quote!(#path(#field_expr)));
+    for (i, field) in fields.iter().enumerate() {
+        if field.attrs.skip_serializing() {
+            continue;
+        }
+        let mut field_expr = if is_enum {
+            let id = field_i(i);
+            quote!(#id)
+        } else {
+            get_member(
+                params,
+                field,
+                &Member::Unnamed(Index {
+                    index: i as u32,
+                    span: Span::call_site(),
+                }),
+            )
+        };
 
-            if let Some(path) = field.attrs.serialize_with() {
-                field_expr = wrap_serialize_field_with(params, field.ty, path, &field_expr);
-            }
+        let skip = field
+            .attrs
+            .skip_serializing_if()
+            .map(|path| quote!(#path(#field_expr)));
 
-            let span = field.original.span();
-            let func = tuple_trait.serialize_element(span);
-            let ser = quote! {
-                #func(&mut __serde_state, #field_expr)?;
-            };
+        if let Some(path) = field.attrs.serialize_with() {
+            field_expr = wrap_serialize_field_with(params, field.ty, path, &field_expr);
+        }
 
-            match skip {
-                None => ser,
-                Some(skip) => quote!(if !#skip { #ser }),
-            }
-        })
-        .collect()
+        let span = field.original.span();
+        let func = tuple_trait.serialize_element(span);
+        let ser = quote! {
+            #func(&mut __serde_state, #field_expr)?;
+        };
+
+        dst_fields.push(match skip {
+            None => ser,
+            Some(skip) => quote!(if !#skip { #ser }),
+        });
+    }
+    dst_fields
 }
 
 fn serialize_struct_visitor(
@@ -1188,9 +1189,7 @@ fn wrap_serialize_variant_with(
         .map(|field| {
             let id = match &field.member {
                 Member::Named(ident) => ident.clone(),
-                Member::Unnamed(member) => {
-                    Ident::new(&format!("__field{}", member.index), Span::call_site())
-                }
+                Member::Unnamed(member) => field_i(member.index as usize),
             };
             quote!(#id)
         })