Add #[eure(flatten)] field attribute for ParseDocument derive

Allows embedding fields from a nested struct into the parent during
parsing. Uses the existing FlattenContext runtime infrastructure.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: ryo33

crates/eure-macros/src/attrs/field.rs

@@ -0,0 +1,7 @@
+use darling::FromField;
+
+#[derive(Debug, Default, FromField)]
+#[darling(default, attributes(eure))]
+pub struct FieldAttrs {
+    pub flatten: bool,
+}

crates/eure-macros/src/attrs/mod.rs

@@ -1,5 +1,7 @@
 mod container;
+mod field;
 mod rename_all;
 
 pub use container::ContainerAttrs;
+pub use field::FieldAttrs;
 pub use rename_all::RenameAll;

crates/eure-macros/src/parse_document/parse_record.rs

@@ -1,10 +1,12 @@
 #[cfg(test)]
 mod tests;
 
+use darling::FromField;
 use proc_macro2::TokenStream;
 use quote::{format_ident, quote};
 use syn::{DataStruct, Fields};
 
+use crate::attrs::FieldAttrs;
 use crate::context::MacroContext;
 
 pub fn generate_record_parser(context: &MacroContext, input: &DataStruct) -> TokenStream {
@@ -37,19 +39,26 @@ fn generate_named_struct_from_record(
     ident: &syn::Ident,
     fields: &syn::punctuated::Punctuated<syn::Field, syn::token::Comma>,
 ) -> TokenStream {
-    let field_names: Vec<_> = fields
+    let field_assignments: Vec<_> = fields
         .iter()
-        .map(|f| f.ident.as_ref().expect("named fields must have names"))
-        .collect();
-    let field_name_strs: Vec<_> = field_names
-        .iter()
-        .map(|n| context.apply_rename(&n.to_string()))
+        .map(|f| {
+            let field_name = f.ident.as_ref().expect("named fields must have names");
+            let field_ty = &f.ty;
+            let attrs = FieldAttrs::from_field(f).expect("failed to parse field attributes");
+
+            if attrs.flatten {
+                quote! { #field_name: #field_ty::parse(&rec.flatten())? }
+            } else {
+                let field_name_str = context.apply_rename(&field_name.to_string());
+                quote! { #field_name: rec.parse_field(#field_name_str)? }
+            }
+        })
         .collect();
 
     context.impl_parse_document(quote! {
         let mut rec = ctx.parse_record()?;
         let value = #ident {
-            #(#field_names: rec.parse_field(#field_name_strs)?),*
+            #(#field_assignments),*
         };
         rec.deny_unknown_fields()?;
         Ok(value)
@@ -61,19 +70,26 @@ fn generate_named_struct_from_ext(
     ident: &syn::Ident,
     fields: &syn::punctuated::Punctuated<syn::Field, syn::token::Comma>,
 ) -> TokenStream {
-    let field_names: Vec<_> = fields
+    let field_assignments: Vec<_> = fields
         .iter()
-        .map(|f| f.ident.as_ref().expect("named fields must have names"))
-        .collect();
-    let field_name_strs: Vec<_> = field_names
-        .iter()
-        .map(|n| context.apply_rename(&n.to_string()))
+        .map(|f| {
+            let field_name = f.ident.as_ref().expect("named fields must have names");
+            let field_ty = &f.ty;
+            let attrs = FieldAttrs::from_field(f).expect("failed to parse field attributes");
+
+            if attrs.flatten {
+                quote! { #field_name: #field_ty::parse(&ext.flatten())? }
+            } else {
+                let field_name_str = context.apply_rename(&field_name.to_string());
+                quote! { #field_name: ext.parse_ext(#field_name_str)? }
+            }
+        })
         .collect();
 
     context.impl_parse_document(quote! {
         let mut ext = ctx.parse_extension();
         let value = #ident {
-            #(#field_names: ext.parse_ext(#field_name_strs)?),*
+            #(#field_assignments),*
         };
         ext.allow_unknown_extensions();
         Ok(value)

crates/eure-macros/src/parse_document/parse_record/tests.rs

@@ -247,3 +247,97 @@ fn test_parse_ext_with_rename_all() {
         .to_string()
     );
 }
+
+#[test]
+fn test_flatten_field() {
+    let input = generate(parse_quote! {
+        struct Person {
+            name: String,
+            #[eure(flatten)]
+            address: Address,
+        }
+    });
+    assert_eq!(
+        input.to_string(),
+        quote! {
+            impl<'doc,> ::eure::document::parse::ParseDocument<'doc> for Person<> {
+                type Error = ::eure::document::parse::ParseError;
+
+                fn parse(ctx: &::eure::document::parse::ParseContext<'doc>) -> Result<Self, Self::Error> {
+                    let mut rec = ctx.parse_record()?;
+                    let value = Person {
+                        name: rec.parse_field("name")?,
+                        address: Address::parse(&rec.flatten())?
+                    };
+                    rec.deny_unknown_fields()?;
+                    Ok(value)
+                }
+            }
+        }
+        .to_string()
+    );
+}
+
+#[test]
+fn test_multiple_flatten_fields() {
+    let input = generate(parse_quote! {
+        struct Combined {
+            id: i32,
+            #[eure(flatten)]
+            personal: PersonalInfo,
+            #[eure(flatten)]
+            contact: ContactInfo,
+        }
+    });
+    assert_eq!(
+        input.to_string(),
+        quote! {
+            impl<'doc,> ::eure::document::parse::ParseDocument<'doc> for Combined<> {
+                type Error = ::eure::document::parse::ParseError;
+
+                fn parse(ctx: &::eure::document::parse::ParseContext<'doc>) -> Result<Self, Self::Error> {
+                    let mut rec = ctx.parse_record()?;
+                    let value = Combined {
+                        id: rec.parse_field("id")?,
+                        personal: PersonalInfo::parse(&rec.flatten())?,
+                        contact: ContactInfo::parse(&rec.flatten())?
+                    };
+                    rec.deny_unknown_fields()?;
+                    Ok(value)
+                }
+            }
+        }
+        .to_string()
+    );
+}
+
+#[test]
+fn test_flatten_with_rename_all() {
+    let input = generate(parse_quote! {
+        #[eure(rename_all = "camelCase")]
+        struct Person {
+            full_name: String,
+            #[eure(flatten)]
+            address_info: AddressInfo,
+        }
+    });
+    assert_eq!(
+        input.to_string(),
+        quote! {
+            impl<'doc,> ::eure::document::parse::ParseDocument<'doc> for Person<> {
+                type Error = ::eure::document::parse::ParseError;
+
+                fn parse(ctx: &::eure::document::parse::ParseContext<'doc>) -> Result<Self, Self::Error> {
+                    let mut rec = ctx.parse_record()?;
+                    let value = Person {
+                        full_name: rec.parse_field("fullName")?,
+                        address_info: AddressInfo::parse(&rec.flatten())?
+                    };
+                    rec.deny_unknown_fields()?;
+                    Ok(value)
+                }
+            }
+        }
+        .to_string()
+    );
+}

crates/eure-macros/src/parse_document/parse_union.rs

@@ -1,10 +1,12 @@
 #[cfg(test)]
 mod tests;
 
+use darling::FromField;
 use proc_macro2::TokenStream;
 use quote::{format_ident, quote};
 use syn::{DataEnum, Fields, Variant};
 
+use crate::attrs::FieldAttrs;
 use crate::{config::MacroConfig, context::MacroContext};
 
 pub fn generate_union_parser(context: &MacroContext, input: &DataEnum) -> TokenStream {
@@ -101,20 +103,27 @@ fn generate_struct_variant(
     variant_ident: &syn::Ident,
     fields: &syn::punctuated::Punctuated<syn::Field, syn::token::Comma>,
 ) -> TokenStream {
-    let field_names: Vec<_> = fields
+    let field_assignments: Vec<_> = fields
         .iter()
-        .map(|f| f.ident.as_ref().expect("struct fields must have names"))
-        .collect();
-    let field_name_strs: Vec<_> = field_names
-        .iter()
-        .map(|n| context.apply_field_rename(&n.to_string()))
+        .map(|f| {
+            let field_name = f.ident.as_ref().expect("struct fields must have names");
+            let field_ty = &f.ty;
+            let attrs = FieldAttrs::from_field(f).expect("failed to parse field attributes");
+
+            if attrs.flatten {
+                quote! { #field_name: #field_ty::parse(&rec.flatten())? }
+            } else {
+                let field_name_str = context.apply_field_rename(&field_name.to_string());
+                quote! { #field_name: rec.parse_field(#field_name_str)? }
+            }
+        })
         .collect();
 
     quote! {
         .variant(#variant_name, |ctx: &#document_crate::parse::ParseContext<'_>| {
             let mut rec = ctx.parse_record()?;
             let value = #enum_ident::#variant_ident {
-                #(#field_names: rec.parse_field(#field_name_strs)?),*
+                #(#field_assignments),*
             };
             rec.deny_unknown_fields()?;
             Ok(value)

crates/eure-macros/src/parse_document/parse_union/tests.rs

@@ -316,3 +316,39 @@ fn test_struct_variant_with_both_rename_all_and_rename_all_fields() {
         .to_string()
     );
 }
+
+#[test]
+fn test_struct_variant_with_flatten() {
+    let input = generate(parse_quote! {
+        enum Entity {
+            Person {
+                name: String,
+                #[eure(flatten)]
+                details: PersonDetails,
+            },
+        }
+    });
+    assert_eq!(
+        input.to_string(),
+        quote! {
+            impl<'doc,> ::eure::document::parse::ParseDocument<'doc> for Entity<> {
+                type Error = ::eure::document::parse::ParseError;
+
+                fn parse(ctx: &::eure::document::parse::ParseContext<'doc>) -> Result<Self, Self::Error> {
+                    ctx.parse_union(::eure::document::data_model::VariantRepr::default())?
+                        .variant("Person", |ctx: &::eure::document::parse::ParseContext<'_>| {
+                            let mut rec = ctx.parse_record()?;
+                            let value = Entity::Person {
+                                name: rec.parse_field("name")?,
+                                details: PersonDetails::parse(&rec.flatten())?
+                            };
+                            rec.deny_unknown_fields()?;
+                            Ok(value)
+                        })
+                        .parse()
+                }
+            }
+        }
+        .to_string()
+    );
+}

crates/eure-macros/tests/records/flatten.rs

@@ -0,0 +1,93 @@
+use eure::ParseDocument;
+
+#[derive(Debug, PartialEq, ParseDocument)]
+#[eure(crate = ::eure::document)]
+struct Address {
+    city: String,
+    country: String,
+}
+
+#[derive(Debug, PartialEq, ParseDocument)]
+#[eure(crate = ::eure::document)]
+struct Person {
+    name: String,
+    #[eure(flatten)]
+    address: Address,
+}
+
+#[derive(Debug, PartialEq, ParseDocument)]
+#[eure(crate = ::eure::document)]
+struct ContactInfo {
+    email: String,
+    phone: String,
+}
+
+#[derive(Debug, PartialEq, ParseDocument)]
+#[eure(crate = ::eure::document)]
+struct FullProfile {
+    id: i32,
+    #[eure(flatten)]
+    address: Address,
+    #[eure(flatten)]
+    contact: ContactInfo,
+}
+
+#[test]
+fn test_flatten_basic() {
+    use eure::eure;
+    let doc = eure!({ name = "Alice", city = "Tokyo", country = "Japan" });
+    assert_eq!(
+        doc.parse::<Person>(doc.get_root_id()).unwrap(),
+        Person {
+            name: "Alice".to_string(),
+            address: Address {
+                city: "Tokyo".to_string(),
+                country: "Japan".to_string(),
+            }
+        }
+    );
+}
+
+#[test]
+fn test_flatten_multiple() {
+    use eure::eure;
+    let doc = eure!({
+        id = 42,
+        city = "New York",
+        country = "USA",
+        email = "test@example.com",
+        phone = "123-456-7890"
+    });
+    assert_eq!(
+        doc.parse::<FullProfile>(doc.get_root_id()).unwrap(),
+        FullProfile {
+            id: 42,
+            address: Address {
+                city: "New York".to_string(),
+                country: "USA".to_string(),
+            },
+            contact: ContactInfo {
+                email: "test@example.com".to_string(),
+                phone: "123-456-7890".to_string(),
+            }
+        }
+    );
+}
+
+#[test]
+fn test_flatten_unknown_field_error() {
+    use eure::eure;
+    // Unknown field should be detected by root parser
+    let doc = eure!({ name = "Alice", city = "Tokyo", country = "Japan", extra = "field" });
+    let result = doc.parse::<Person>(doc.get_root_id());
+    assert!(result.is_err());
+}
+
+#[test]
+fn test_flatten_missing_field_error() {
+    use eure::eure;
+    // Missing required field in flattened type
+    let doc = eure!({ name = "Alice", city = "Tokyo" }); // missing country
+    let result = doc.parse::<Person>(doc.get_root_id());
+    assert!(result.is_err());
+}