from_row: adjust code for named fields

This commit prepares for code generation for unnamed fields.
The behaviour for named fields becomes unchanged, however code
generation logic was slightly adjusted so the very similar approach
can be applied to unnamed fields.

Author: muzarski

scylla-macros/src/from_row.rs

@@ -6,33 +6,43 @@ use syn::{spanned::Spanned, DeriveInput};
 pub(crate) fn from_row_derive(tokens_input: TokenStream) -> Result<TokenStream, syn::Error> {
     let item = syn::parse::<DeriveInput>(tokens_input)?;
     let path = crate::parser::get_path(&item)?;
-    let struct_fields = crate::parser::parse_named_fields(&item, "FromRow")?;
+    let struct_fields = crate::parser::parse_struct_fields(&item, "FromRow")?;
 
     let struct_name = &item.ident;
     let (impl_generics, ty_generics, where_clause) = item.generics.split_for_impl();
 
-    // Generates tokens for field_name: field_type::from_cql(vals_iter.next().ok_or(...)?), ...
-    let set_fields_code = struct_fields.named.iter().map(|field| {
-        let field_name = &field.ident;
-        let field_type = &field.ty;
-
-        quote_spanned! {field.span() =>
-            #field_name: {
-                let (col_ix, col_value) = vals_iter
-                    .next()
-                    .unwrap(); // vals_iter size is checked before this code is reached, so
-                               // it is safe to unwrap
-
-                <#field_type as FromCqlVal<::std::option::Option<CqlValue>>>::from_cql(col_value)
-                    .map_err(|e| FromRowError::BadCqlVal {
-                        err: e,
-                        column: col_ix,
-                    })?
-            },
+    // Generates a token that sets the values of struct fields: field_type::from_cql(...)
+    let (fill_struct_code, fields_count) = match struct_fields {
+        crate::parser::StructFields::Named(fields) => {
+            let set_fields_code = fields.named.iter().map(|field| {
+                let field_name = &field.ident;
+                let field_type = &field.ty;
+
+                quote_spanned! {field.span() =>
+                    #field_name: {
+                        let (col_ix, col_value) = vals_iter
+                            .next()
+                            .unwrap(); // vals_iter size is checked before this code is reached, so
+                                    // it is safe to unwrap
+
+                        <#field_type as FromCqlVal<::std::option::Option<CqlValue>>>::from_cql(col_value)
+                            .map_err(|e| FromRowError::BadCqlVal {
+                                err: e,
+                                column: col_ix,
+                            })?
+                    },
+                }
+            });
+
+            // This generates: { field1: {field1_code}, field2: {field2_code}, ...}
+            let fill_struct_code = quote! {
+                {#(#set_fields_code)*}
+            };
+            (fill_struct_code, fields.named.len())
         }
-    });
+        crate::parser::StructFields::Unnamed(_fields) => todo!(),
+    };
 
-    let fields_count = struct_fields.named.len();
     let generated = quote! {
         impl #impl_generics #path::FromRow for #struct_name #ty_generics #where_clause {
             fn from_row(row: #path::Row)
@@ -49,9 +59,7 @@ pub(crate) fn from_row_derive(tokens_input: TokenStream) -> Result<TokenStream,
                 }
                 let mut vals_iter = row.columns.into_iter().enumerate();
 
-                Ok(#struct_name {
-                    #(#set_fields_code)*
-                })
+                Ok(#struct_name #fill_struct_code)
             }
         }
     };