Add parse_ext container attribute for ParseDocument derive

Add support for parsing struct fields from extension namespace ($ext-type)
instead of record fields. When #[eure(parse_ext)] is specified on a struct,
the generated code uses ctx.parse_extension() and ext.parse_ext() instead of
ctx.parse_record() and rec.parse_field().

This allows types like ParsedRecordFieldSchema to be derived rather than
manually implemented.

Author: claude

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

@@ -12,4 +12,8 @@ pub struct ContainerAttrs {
     /// Renames all struct variant fields in an enum.
     /// Unlike `rename_all`, this only applies to fields within struct variants.
     pub rename_all_fields: Option<RenameAll>,
+    /// Parse fields from extension namespace ($ext-type) instead of record fields.
+    /// When true, uses `ctx.parse_extension()` and `ext.parse_ext()` instead of
+    /// `ctx.parse_record()` and `rec.parse_field()`.
+    pub parse_ext: bool,
 }

crates/eure-macros/src/config.rs

@@ -7,6 +7,8 @@ pub struct MacroConfig {
     pub document_crate: TokenStream,
     pub rename_all: Option<RenameAll>,
     pub rename_all_fields: Option<RenameAll>,
+    /// Parse fields from extension namespace instead of record fields.
+    pub parse_ext: bool,
 }
 
 impl MacroConfig {
@@ -20,6 +22,7 @@ impl MacroConfig {
             document_crate,
             rename_all: attrs.rename_all,
             rename_all_fields: attrs.rename_all_fields,
+            parse_ext: attrs.parse_ext,
         }
     }
 }

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

@@ -24,6 +24,18 @@ fn generate_named_struct(
     context: &MacroContext,
     ident: &syn::Ident,
     fields: &syn::punctuated::Punctuated<syn::Field, syn::token::Comma>,
+) -> TokenStream {
+    if context.config.parse_ext {
+        generate_named_struct_from_ext(context, ident, fields)
+    } else {
+        generate_named_struct_from_record(context, ident, fields)
+    }
+}
+
+fn generate_named_struct_from_record(
+    context: &MacroContext,
+    ident: &syn::Ident,
+    fields: &syn::punctuated::Punctuated<syn::Field, syn::token::Comma>,
 ) -> TokenStream {
     let field_names: Vec<_> = fields
         .iter()
@@ -44,6 +56,30 @@ fn generate_named_struct(
     })
 }
 
+fn generate_named_struct_from_ext(
+    context: &MacroContext,
+    ident: &syn::Ident,
+    fields: &syn::punctuated::Punctuated<syn::Field, syn::token::Comma>,
+) -> TokenStream {
+    let field_names: 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()))
+        .collect();
+
+    context.impl_parse_document(quote! {
+        let mut ext = ctx.parse_extension();
+        let value = #ident {
+            #(#field_names: ext.parse_ext(#field_name_strs)?),*
+        };
+        ext.allow_unknown_extensions();
+        Ok(value)
+    })
+}
+
 fn generate_unit_struct(context: &MacroContext, ident: &syn::Ident) -> TokenStream {
     context.impl_parse_document(quote! {
         ctx.parse::<()>()?;

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

@@ -187,3 +187,63 @@ fn test_named_fields_struct_with_rename_all_kebab_case() {
         .to_string()
     );
 }
+
+#[test]
+fn test_parse_ext_basic() {
+    let input = generate(parse_quote! {
+        #[eure(parse_ext)]
+        struct ExtFields {
+            optional: bool,
+            deprecated: bool,
+        }
+    });
+    assert_eq!(
+        input.to_string(),
+        quote! {
+            impl<'doc,> ::eure::document::parse::ParseDocument<'doc> for ExtFields<> {
+                type Error = ::eure::document::parse::ParseError;
+
+                fn parse(ctx: &::eure::document::parse::ParseContext<'doc>) -> Result<Self, Self::Error> {
+                    let mut ext = ctx.parse_extension();
+                    let value = ExtFields {
+                        optional: ext.parse_ext("optional")?,
+                        deprecated: ext.parse_ext("deprecated")?
+                    };
+                    ext.allow_unknown_extensions();
+                    Ok(value)
+                }
+            }
+        }
+        .to_string()
+    );
+}
+
+#[test]
+fn test_parse_ext_with_rename_all() {
+    let input = generate(parse_quote! {
+        #[eure(parse_ext, rename_all = "kebab-case")]
+        struct ExtFields {
+            binding_style: String,
+            deny_untagged: bool,
+        }
+    });
+    assert_eq!(
+        input.to_string(),
+        quote! {
+            impl<'doc,> ::eure::document::parse::ParseDocument<'doc> for ExtFields<> {
+                type Error = ::eure::document::parse::ParseError;
+
+                fn parse(ctx: &::eure::document::parse::ParseContext<'doc>) -> Result<Self, Self::Error> {
+                    let mut ext = ctx.parse_extension();
+                    let value = ExtFields {
+                        binding_style: ext.parse_ext("binding-style")?,
+                        deny_untagged: ext.parse_ext("deny-untagged")?
+                    };
+                    ext.allow_unknown_extensions();
+                    Ok(value)
+                }
+            }
+        }
+        .to_string()
+    );
+}