Increment members counter regardless of whether field is unnamed

Syn would never parse a Fields containing a mix of named and unnamed
fields, but if such a Fields is constructed in another way, it makes
more sense for members() to produce the index for the unnamed field's
position in the entire list.

src/data.rs

@@ -111,46 +111,44 @@ impl Fields {
     pub fn members(&self) -> impl Iterator<Item = Member> + Clone + '_ {
         struct Members<'a> {
             iter: punctuated::Iter<'a, Field>,
-            unnamed_counter: u32,
+            index: u32,
         }
 
         impl<'a> Iterator for Members<'a> {
             type Item = Member;
 
             fn next(&mut self) -> Option<Self::Item> {
                 let field = self.iter.next()?;
-                match &field.ident {
-                    Some(ident) => Some(Member::Named(ident.clone())),
-                    None => {
-                        let m = Member::Unnamed(crate::Index {
-                            index: self.unnamed_counter,
-                            span: {
-                                #[cfg(all(feature = "parsing", feature = "printing"))]
-                                let span = crate::spanned::Spanned::span(&field.ty);
-                                #[cfg(not(all(feature = "parsing", feature = "printing")))]
-                                let span = proc_macro2::Span::call_site();
-                                span
-                            },
-                        });
-                        self.unnamed_counter += 1;
-                        Some(m)
-                    }
-                }
+                let member = match &field.ident {
+                    Some(ident) => Member::Named(ident.clone()),
+                    None => Member::Unnamed(crate::Index {
+                        index: self.index,
+                        span: {
+                            #[cfg(all(feature = "parsing", feature = "printing"))]
+                            let span = crate::spanned::Spanned::span(&field.ty);
+                            #[cfg(not(all(feature = "parsing", feature = "printing")))]
+                            let span = proc_macro2::Span::call_site();
+                            span
+                        },
+                    }),
+                };
+                self.index += 1;
+                Some(member)
             }
         }
 
         impl<'a> Clone for Members<'a> {
             fn clone(&self) -> Self {
                 Members {
                     iter: self.iter.clone(),
-                    unnamed_counter: self.unnamed_counter,
+                    index: self.index,
                 }
             }
         }
 
         Members {
             iter: self.iter(),
-            unnamed_counter: 0,
+            index: 0,
         }
     }
 }