Skip to main content

hyprstream_rpc_derive/codegen/
data.rs

1//! Data struct and enum type generation with ToCapnp/FromCapnp trait impls.
2
3use proc_macro2::TokenStream;
4use quote::{format_ident, quote};
5
6use crate::resolve::ResolvedSchema;
7use crate::schema::types::collect_list_struct_types;
8use crate::schema::types::*;
9use crate::util::*;
10
11/// Resolve a field-level `$domainType("path::Type")` annotation to its Rust type tokens.
12///
13/// Unlike the struct-level `resolve_domain_type` (which prepends the generated crate prefix
14/// for return-type wrappers), field newtypes live in shared crates and are referenced by their
15/// absolute path verbatim (e.g. `hyprstream_rpc::identity::Did`), so the path resolves
16/// identically from every generated module regardless of `types_crate`.
17fn resolve_field_domain_type(domain_path: &str) -> TokenStream {
18    domain_path.parse().unwrap_or_else(|_| quote! { String })
19}
20
21/// Resolve the capnp module path for a type based on its origin file.
22fn resolve_capnp_mod(
23    origin_file: Option<&str>,
24    service_name: &str,
25    types_crate: Option<&syn::Path>,
26) -> TokenStream {
27    let mod_name = origin_file.unwrap_or(service_name);
28    let capnp_mod_ident = format_ident!("{}_capnp", mod_name);
29    match types_crate {
30        Some(tc) => quote! { #tc::#capnp_mod_ident },
31        None => quote! { crate::#capnp_mod_ident },
32    }
33}
34
35/// Generate Rust data structs with ToCapnp/FromCapnp impls, and enum types.
36pub fn generate_data_structs(
37    resolved: &ResolvedSchema,
38    service_name: &str,
39    types_crate: Option<&syn::Path>,
40) -> TokenStream {
41    let mut tokens = TokenStream::new();
42
43    // Generate enum types
44    for e in &resolved.raw.enums {
45        tokens.extend(generate_enum_type(e, resolved));
46    }
47
48    // Known service names that have their own `_client` module.
49    // Types imported from one of these are emitted as `pub type Foo = super::{origin}_client::Foo;`
50    // instead of full struct + trait impls, avoiding duplicate definitions.
51    const SERVICE_MODULES: &[&str] = &["inference", "model", "registry", "policy", "worker", "mcp"];
52
53    // For data-only schemas (no request/response unions), generate ALL structs.
54    // For service schemas, only generate types referenced by variants.
55    let is_data_only = resolved.raw.request_variants.is_empty();
56    let list_struct_types = if is_data_only {
57        resolved
58            .raw
59            .structs
60            .iter()
61            .map(|s| s.name.clone())
62            .collect()
63    } else {
64        collect_list_struct_types(resolved.raw)
65    };
66    for type_name in &list_struct_types {
67        // Synthetic capnp group nodes are named `Parent.armName` (e.g.
68        // `Ordering.unordered`). They are not standalone Rust types — their leaf
69        // fields are folded into the parent union's enum variant — and the dotted
70        // name is not a valid Rust identifier, so skip them here.
71        if type_name.contains('.') {
72            continue;
73        }
74        if let Some(s) = resolved.find_struct(type_name) {
75            // Skip Option* wrapper structs — they become Option<T> fields, not standalone types
76            if s.option_inner_type().is_some() {
77                continue;
78            }
79
80            // If this type originates from a different service's schema, emit a `pub type` alias
81            // instead of a full struct definition. This avoids duplicate types and the need for
82            // hand-written `From` impls between structurally identical generated types.
83            if let Some(origin) = s.origin_file.as_deref() {
84                if origin != service_name && SERVICE_MODULES.contains(&origin) {
85                    let data_name = format_ident!("{}", type_name);
86                    let origin_mod = format_ident!("{}_client", origin);
87                    tokens.extend(quote! {
88                        pub type #data_name = super::#origin_mod::#data_name;
89                    });
90                    continue;
91                }
92
93                // Types originating from RPC infrastructure schemas (e.g. streaming.capnp)
94                // alias to the canonical type in hyprstream_rpc instead of generating duplicates.
95                const RPC_CRATE_MODULES: &[(&str, &str)] = &[
96                    ("streaming", "hyprstream_rpc::stream_info"),
97                    ("common", "hyprstream_rpc::common_types"),
98                ];
99                if origin != service_name {
100                    if let Some((_, rpc_mod)) =
101                        RPC_CRATE_MODULES.iter().find(|(name, _)| *name == origin)
102                    {
103                        let data_name = format_ident!("{}", type_name);
104                        #[allow(clippy::expect_used)] // compile-time constant path
105                        let rpc_path: syn::Path =
106                            syn::parse_str(rpc_mod).expect("invalid RPC_CRATE_MODULES path");
107                        tokens.extend(quote! {
108                            pub type #data_name = #rpc_path::#data_name;
109                        });
110                        continue;
111                    }
112                }
113            }
114
115            let capnp_mod = resolve_capnp_mod(s.origin_file.as_deref(), service_name, types_crate);
116
117            // Pure tagged-union structs (a capnp `union { ... }` with no sibling
118            // non-union fields) become native Rust enums — one variant per arm —
119            // instead of an (empty) struct. Option<T> wrappers are handled above.
120            if s.is_pure_union() && s.option_inner_type().is_none() {
121                tokens.extend(generate_union_enum(type_name, s, resolved));
122                tokens.extend(generate_union_to_capnp_impl(
123                    type_name,
124                    s,
125                    resolved,
126                    &capnp_mod,
127                    service_name,
128                    types_crate,
129                ));
130                tokens.extend(generate_union_from_capnp_impl(
131                    type_name,
132                    s,
133                    resolved,
134                    &capnp_mod,
135                    service_name,
136                    types_crate,
137                ));
138                continue;
139            }
140
141            tokens.extend(generate_data_struct(type_name, s, resolved));
142            tokens.extend(generate_to_capnp_impl(
143                type_name,
144                s,
145                resolved,
146                &capnp_mod,
147                service_name,
148                types_crate,
149            ));
150            tokens.extend(generate_from_capnp_impl(
151                type_name,
152                s,
153                resolved,
154                &capnp_mod,
155                service_name,
156                types_crate,
157            ));
158        }
159    }
160
161    tokens
162}
163
164fn generate_enum_type(e: &EnumDef, resolved: &ResolvedSchema) -> TokenStream {
165    let enum_name = format_ident!("{}", e.name);
166    let doc = format!("Generated from Cap'n Proto enum {}", e.name);
167
168    let variants: Vec<TokenStream> = e
169        .variants
170        .iter()
171        .enumerate()
172        .map(|(i, (variant_name, _ordinal))| {
173            let variant_ident = resolved.name(variant_name).pascal_ident.clone();
174            if i == 0 {
175                quote! { #[default] #variant_ident }
176            } else {
177                quote! { #variant_ident }
178            }
179        })
180        .collect();
181
182    quote! {
183        #[doc = #doc]
184        #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, serde::Serialize, serde::Deserialize)]
185        pub enum #enum_name {
186            #(#variants,)*
187        }
188    }
189}
190
191fn generate_data_struct(type_name: &str, s: &StructDef, resolved: &ResolvedSchema) -> TokenStream {
192    let data_name = format_ident!("{}", type_name);
193    let doc = format!("Generated from Cap'n Proto struct {type_name}");
194
195    let fields: Vec<TokenStream> = s
196        .non_union_fields()
197        .map(|field| {
198            let rust_name = resolved.name(&field.name).snake_ident.clone();
199            // Check if field type is an Option* wrapper struct (e.g. OptionFloat32 → Option<f32>)
200            let option_inner = resolved.find_struct(&field.type_name)
201                .and_then(|s| s.option_inner_type())
202                .map(|inner_name| rust_type_tokens(&resolved.resolve_type(inner_name).rust_owned));
203
204            let inner_type = if let Some(dt) = field.domain_type.as_deref() {
205                // Field-level `$domainType`: use the newtype (wire type unchanged).
206                resolve_field_domain_type(dt)
207            } else if field.type_name == "Data" && field.fixed_size.is_some() {
208                let n = field.fixed_size.unwrap_or(0);
209                // Arrays > 32 don't implement Default/Serialize/Deserialize via derive,
210                // so use Vec<u8> in the struct. ToCapnp/FromCapnp handle length validation.
211                if n <= 32 {
212                    let n_usize = n as usize;
213                    let ts: TokenStream = format!("[u8; {n_usize}]").parse().unwrap_or_else(|_| quote! { Vec<u8> });
214                    ts
215                } else {
216                    quote! { Vec<u8> }
217                }
218            } else {
219                rust_type_tokens(&resolved.resolve_type(&field.type_name).rust_owned)
220            };
221            let is_option = field.optional || option_inner.is_some();
222            let rust_type = if let Some(ref inner) = option_inner {
223                quote! { Option<#inner> }
224            } else if field.optional {
225                quote! { Option<#inner_type> }
226            } else {
227                inner_type
228            };
229            let serde_attr = if let Some(ref rename) = field.serde_rename {
230                if is_option {
231                    quote! { #[serde(rename = #rename, skip_serializing_if = "Option::is_none", default)] }
232                } else {
233                    quote! { #[serde(rename = #rename)] }
234                }
235            } else if is_option {
236                quote! { #[serde(skip_serializing_if = "Option::is_none", default)] }
237            } else {
238                TokenStream::new()
239            };
240            quote! { #serde_attr pub #rust_name: #rust_type }
241        })
242        .collect();
243
244    // Mixed struct (non-union fields + an anonymous union): fold the union into
245    // a companion enum `{Type}Content` carried as a `content` field so the union
246    // arms round-trip. Pure unions are handled by `generate_union_enum`; structs
247    // with no union skip this entirely.
248    let (content_field, content_enum) = if s.has_union && !s.is_pure_union() {
249        let content_enum_name = format_ident!("{}Content", type_name);
250        let enum_def = generate_mixed_union_enum(type_name, s, resolved);
251        (quote! { pub content: #content_enum_name, }, enum_def)
252    } else {
253        (TokenStream::new(), TokenStream::new())
254    };
255
256    quote! {
257        #content_enum
258        #[doc = #doc]
259        #[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
260        #[serde(rename_all = "camelCase")]
261        pub struct #data_name {
262            #(#fields,)*
263            #content_field
264        }
265    }
266}
267
268/// Generate the companion `{Type}Content` enum for a mixed struct's anonymous
269/// union. Mirrors `generate_union_enum` but emits a distinctly-named enum so it
270/// can be carried as a field of the owning struct.
271fn generate_mixed_union_enum(
272    type_name: &str,
273    s: &StructDef,
274    resolved: &ResolvedSchema,
275) -> TokenStream {
276    let enum_name = format_ident!("{}Content", type_name);
277    let doc = format!("Anonymous union of Cap'n Proto struct {type_name}");
278
279    let default_arm = s.union_arms.iter().find(|a| a.discriminant_value == 0);
280    let default_is_unit = matches!(default_arm.map(|a| &a.payload), Some(ArmPayload::Void));
281
282    let variants: Vec<TokenStream> = s
283        .union_arms
284        .iter()
285        .map(|arm| {
286            let variant_ident = resolved.name(&arm.name).pascal_ident.clone();
287            let default_attr = if arm.discriminant_value == 0 && default_is_unit {
288                quote! { #[default] }
289            } else {
290                TokenStream::new()
291            };
292            match &arm.payload {
293                ArmPayload::Void => quote! { #default_attr #variant_ident },
294                ArmPayload::Type(t) => {
295                    let ty = arm_payload_type_tokens(t, resolved);
296                    quote! { #default_attr #variant_ident(#ty) }
297                }
298                ArmPayload::Group(leaves) => {
299                    let fields: Vec<TokenStream> = leaves
300                        .iter()
301                        .map(|leaf| {
302                            let leaf_name = resolved.name(&leaf.name).snake_ident.clone();
303                            let leaf_ty = arm_payload_type_tokens(&leaf.type_name, resolved);
304                            quote! { #leaf_name: #leaf_ty }
305                        })
306                        .collect();
307                    quote! { #default_attr #variant_ident { #(#fields,)* } }
308                }
309            }
310        })
311        .collect();
312
313    let (derive_default, manual_default) = if default_is_unit {
314        (quote! { Default, }, TokenStream::new())
315    } else {
316        let manual = default_arm
317            .map(|arm| {
318                let variant_ident = resolved.name(&arm.name).pascal_ident.clone();
319                let ctor = match &arm.payload {
320                    ArmPayload::Void => quote! { Self::#variant_ident },
321                    ArmPayload::Type(_) => quote! { Self::#variant_ident(Default::default()) },
322                    ArmPayload::Group(leaves) => {
323                        let fields: Vec<TokenStream> = leaves
324                            .iter()
325                            .map(|leaf| {
326                                let leaf_name = resolved.name(&leaf.name).snake_ident.clone();
327                                quote! { #leaf_name: Default::default() }
328                            })
329                            .collect();
330                        quote! { Self::#variant_ident { #(#fields,)* } }
331                    }
332                };
333                quote! {
334                    impl Default for #enum_name {
335                        fn default() -> Self { #ctor }
336                    }
337                }
338            })
339            .unwrap_or_default();
340        (TokenStream::new(), manual)
341    };
342
343    quote! {
344        #[doc = #doc]
345        #[derive(Debug, Clone, #derive_default PartialEq, serde::Serialize, serde::Deserialize)]
346        #[serde(rename_all = "camelCase")]
347        pub enum #enum_name {
348            #(#variants,)*
349        }
350        #manual_default
351    }
352}
353
354// ─────────────────────────────────────────────────────────────────────────────
355// Tagged-union (pure-union struct) → Rust enum generation
356// ─────────────────────────────────────────────────────────────────────────────
357
358/// Owned Rust type tokens for a single-type union-arm payload.
359fn arm_payload_type_tokens(type_name: &str, resolved: &ResolvedSchema) -> TokenStream {
360    rust_type_tokens(&resolved.resolve_type(type_name).rust_owned)
361}
362
363/// Generate a Rust `enum` for a pure-union capnp struct.
364///
365/// Each arm maps to a variant: Void → unit, single-type → tuple, group → struct.
366/// The discriminant-0 arm carries `#[default]`.
367fn generate_union_enum(type_name: &str, s: &StructDef, resolved: &ResolvedSchema) -> TokenStream {
368    let enum_name = format_ident!("{}", type_name);
369    let doc = format!("Generated from Cap'n Proto union {type_name}");
370
371    // The discriminant-0 arm is the capnp zero-fill default. If it's a Void arm
372    // we can use `#[derive(Default)]` + `#[default]` (requires a unit variant);
373    // otherwise we drop `Default` from the derive and emit a manual `impl Default`
374    // that builds the @0 variant with default-valued payload.
375    let default_arm = s.union_arms.iter().find(|a| a.discriminant_value == 0);
376    let default_is_unit = matches!(default_arm.map(|a| &a.payload), Some(ArmPayload::Void));
377
378    let variants: Vec<TokenStream> = s
379        .union_arms
380        .iter()
381        .map(|arm| {
382            let variant_ident = resolved.name(&arm.name).pascal_ident.clone();
383            let default_attr = if arm.discriminant_value == 0 && default_is_unit {
384                quote! { #[default] }
385            } else {
386                TokenStream::new()
387            };
388            match &arm.payload {
389                ArmPayload::Void => quote! { #default_attr #variant_ident },
390                ArmPayload::Type(t) => {
391                    let ty = arm_payload_type_tokens(t, resolved);
392                    quote! { #default_attr #variant_ident(#ty) }
393                }
394                ArmPayload::Group(leaves) => {
395                    let fields: Vec<TokenStream> = leaves
396                        .iter()
397                        .map(|leaf| {
398                            let leaf_name = resolved.name(&leaf.name).snake_ident.clone();
399                            let leaf_ty = arm_payload_type_tokens(&leaf.type_name, resolved);
400                            quote! { #leaf_name: #leaf_ty }
401                        })
402                        .collect();
403                    quote! { #default_attr #variant_ident { #(#fields,)* } }
404                }
405            }
406        })
407        .collect();
408
409    let (derive_default, manual_default) = if default_is_unit {
410        (quote! { Default, }, TokenStream::new())
411    } else {
412        // Manual Default for a data-carrying @0 arm.
413        let manual = default_arm
414            .map(|arm| {
415                let variant_ident = resolved.name(&arm.name).pascal_ident.clone();
416                let ctor = match &arm.payload {
417                    ArmPayload::Void => quote! { Self::#variant_ident },
418                    ArmPayload::Type(_) => quote! { Self::#variant_ident(Default::default()) },
419                    ArmPayload::Group(leaves) => {
420                        let fields: Vec<TokenStream> = leaves
421                            .iter()
422                            .map(|leaf| {
423                                let leaf_name = resolved.name(&leaf.name).snake_ident.clone();
424                                quote! { #leaf_name: Default::default() }
425                            })
426                            .collect();
427                        quote! { Self::#variant_ident { #(#fields,)* } }
428                    }
429                };
430                quote! {
431                    impl Default for #enum_name {
432                        fn default() -> Self { #ctor }
433                    }
434                }
435            })
436            .unwrap_or_default();
437        (TokenStream::new(), manual)
438    };
439
440    quote! {
441        #[doc = #doc]
442        #[derive(Debug, Clone, #derive_default PartialEq, serde::Serialize, serde::Deserialize)]
443        #[serde(rename_all = "camelCase")]
444        pub enum #enum_name {
445            #(#variants,)*
446        }
447        #manual_default
448    }
449}
450
451/// Generate the value-setter for a scalar/Text/Data/enum/struct union-arm payload.
452///
453/// `value` is a binding (e.g. `v`) holding `&T` for the arm's owned Rust type.
454/// `setter`/`init` are the capnp builder method idents for this arm.
455fn union_arm_value_setter(
456    type_name: &str,
457    value: &TokenStream,
458    setter: &proc_macro2::Ident,
459    init: &proc_macro2::Ident,
460    resolved: &ResolvedSchema,
461    capnp_mod: &TokenStream,
462    service_name: &str,
463    types_crate: Option<&syn::Path>,
464) -> TokenStream {
465    let ct = resolved.resolve_type(type_name).capnp_type.clone();
466    match ct {
467        CapnpType::Bool
468        | CapnpType::UInt8
469        | CapnpType::UInt16
470        | CapnpType::UInt32
471        | CapnpType::UInt64
472        | CapnpType::Int8
473        | CapnpType::Int16
474        | CapnpType::Int32
475        | CapnpType::Int64
476        | CapnpType::Float32
477        | CapnpType::Float64 => {
478            quote! { builder.#setter(*#value); }
479        }
480        CapnpType::Text => quote! { builder.#setter(#value.as_str()); },
481        CapnpType::Data => quote! { builder.#setter(#value.as_slice()); },
482        CapnpType::Enum(ref name) => {
483            if let Some(e) = resolved.find_enum(name) {
484                let field_capnp_mod = resolve_capnp_mod(
485                    lookup_origin_file(name, resolved),
486                    service_name,
487                    types_crate,
488                );
489                let enum_rust = format_ident!("{}", name);
490                let type_ident = format_ident!("{}", name);
491                let arms: Vec<TokenStream> = e
492                    .variants
493                    .iter()
494                    .map(|(vname, _)| {
495                        let vp = resolved.name(vname).pascal_ident.clone();
496                        quote! { #enum_rust::#vp => #field_capnp_mod::#type_ident::#vp }
497                    })
498                    .collect();
499                quote! { builder.#setter(match #value { #(#arms,)* }); }
500            } else {
501                TokenStream::new()
502            }
503        }
504        CapnpType::Struct(_) => {
505            quote! {
506                let mut __arm = builder.reborrow().#init();
507                hyprstream_rpc::capnp::ToCapnp::write_to(#value, &mut __arm);
508            }
509        }
510        _ => {
511            let _ = capnp_mod;
512            TokenStream::new()
513        }
514    }
515}
516
517/// Generate `ToCapnp` for a pure-union enum.
518fn generate_union_to_capnp_impl(
519    type_name: &str,
520    s: &StructDef,
521    resolved: &ResolvedSchema,
522    capnp_mod: &TokenStream,
523    service_name: &str,
524    types_crate: Option<&syn::Path>,
525) -> TokenStream {
526    let enum_name = format_ident!("{}", type_name);
527    let capnp_struct = format_ident!("{}", to_capnp_module_name(type_name));
528
529    let arms: Vec<TokenStream> = s.union_arms.iter().map(|arm| {
530        let variant = resolved.name(&arm.name).pascal_ident.clone();
531        let arm_snake = &resolved.name(&arm.name).snake;
532        let setter = format_ident!("set_{}", arm_snake);
533        let init = format_ident!("init_{}", arm_snake);
534        match &arm.payload {
535            ArmPayload::Void => {
536                quote! { Self::#variant => builder.#setter(()), }
537            }
538            ArmPayload::Type(t) => {
539                let value = quote! { v };
540                let set = union_arm_value_setter(t, &value, &setter, &init, resolved, capnp_mod, service_name, types_crate);
541                quote! { Self::#variant(v) => { #set } }
542            }
543            ArmPayload::Group(leaves) => {
544                let leaf_binds: Vec<TokenStream> = leaves.iter().map(|leaf| {
545                    let leaf_name = resolved.name(&leaf.name).snake_ident.clone();
546                    quote! { #leaf_name }
547                }).collect();
548                let leaf_sets: Vec<TokenStream> = leaves.iter().map(|leaf| {
549                    let leaf_snake = &resolved.name(&leaf.name).snake;
550                    let leaf_name = resolved.name(&leaf.name).snake_ident.clone();
551                    let leaf_setter = format_ident!("set_{}", leaf_snake);
552                    let ct = resolved.resolve_type(&leaf.type_name).capnp_type.clone();
553                    match ct {
554                        CapnpType::Text => quote! { __g.#leaf_setter(#leaf_name.as_str()); },
555                        CapnpType::Data => quote! { __g.#leaf_setter(#leaf_name.as_slice()); },
556                        CapnpType::Struct(_) => quote! {
557                            hyprstream_rpc::capnp::ToCapnp::write_to(#leaf_name, &mut __g.reborrow().#leaf_setter());
558                        },
559                        _ => quote! { __g.#leaf_setter(*#leaf_name); },
560                    }
561                }).collect();
562                quote! {
563                    Self::#variant { #(#leaf_binds,)* } => {
564                        let mut __g = builder.reborrow().#init();
565                        #(#leaf_sets)*
566                    }
567                }
568            }
569        }
570    }).collect();
571
572    quote! {
573        impl hyprstream_rpc::capnp::ToCapnp for #enum_name {
574            type Builder<'a> = #capnp_mod::#capnp_struct::Builder<'a>;
575
576            #[allow(unused_variables, unused_mut)]
577            fn write_to(&self, builder: &mut Self::Builder<'_>) {
578                match self {
579                    #(#arms)*
580                }
581            }
582        }
583    }
584}
585
586/// Generate `FromCapnp` for a pure-union enum.
587fn generate_union_from_capnp_impl(
588    type_name: &str,
589    s: &StructDef,
590    resolved: &ResolvedSchema,
591    capnp_mod: &TokenStream,
592    service_name: &str,
593    types_crate: Option<&syn::Path>,
594) -> TokenStream {
595    let enum_name = format_ident!("{}", type_name);
596    let capnp_struct = format_ident!("{}", to_capnp_module_name(type_name));
597    let union_mod = format_ident!("{}", to_capnp_module_name(type_name));
598
599    let arms: Vec<TokenStream> = s.union_arms.iter().map(|arm| {
600        let variant = resolved.name(&arm.name).pascal_ident.clone();
601        match &arm.payload {
602            ArmPayload::Void => {
603                quote! { #capnp_mod::#union_mod::Which::#variant(()) => Self::#variant, }
604            }
605            ArmPayload::Type(t) => {
606                let ct = resolved.resolve_type(t).capnp_type.clone();
607                match ct {
608                    // Scalars bind the value directly; no Result.
609                    CapnpType::Bool | CapnpType::UInt8 | CapnpType::UInt16 | CapnpType::UInt32 | CapnpType::UInt64
610                    | CapnpType::Int8 | CapnpType::Int16 | CapnpType::Int32 | CapnpType::Int64
611                    | CapnpType::Float32 | CapnpType::Float64 => {
612                        quote! { #capnp_mod::#union_mod::Which::#variant(v) => Self::#variant(v), }
613                    }
614                    // Text / Data / Struct bind a Result<Reader> — unwrap with `?`.
615                    CapnpType::Text => {
616                        quote! { #capnp_mod::#union_mod::Which::#variant(v) => Self::#variant(v?.to_str()?.to_string()), }
617                    }
618                    CapnpType::Data => {
619                        quote! { #capnp_mod::#union_mod::Which::#variant(v) => Self::#variant(v?.to_vec()), }
620                    }
621                    CapnpType::Enum(ref name) => {
622                        if let Some(e) = resolved.find_enum(name) {
623                            let field_capnp_mod = resolve_capnp_mod(
624                                lookup_origin_file(name, resolved),
625                                service_name,
626                                types_crate,
627                            );
628                            let enum_rust = format_ident!("{}", name);
629                            let type_ident = format_ident!("{}", name);
630                            let match_arms: Vec<TokenStream> = e.variants.iter().map(|(vname, _)| {
631                                let vp = resolved.name(vname).pascal_ident.clone();
632                                quote! { #field_capnp_mod::#type_ident::#vp => #enum_rust::#vp }
633                            }).collect();
634                            quote! { #capnp_mod::#union_mod::Which::#variant(v) => Self::#variant(match v? { #(#match_arms,)* }), }
635                        } else {
636                            quote! { #capnp_mod::#union_mod::Which::#variant(_) => Self::#variant(Default::default()), }
637                        }
638                    }
639                    CapnpType::Struct(_) => {
640                        quote! { #capnp_mod::#union_mod::Which::#variant(r) => Self::#variant(hyprstream_rpc::capnp::FromCapnp::read_from(r?)?), }
641                    }
642                    _ => quote! { #capnp_mod::#union_mod::Which::#variant(_) => Self::#variant(Default::default()), },
643                }
644            }
645            ArmPayload::Group(leaves) => {
646                let leaf_reads: Vec<TokenStream> = leaves.iter().map(|leaf| {
647                    let leaf_name = resolved.name(&leaf.name).snake_ident.clone();
648                    let leaf_getter = format_ident!("get_{}", resolved.name(&leaf.name).snake);
649                    let ct = resolved.resolve_type(&leaf.type_name).capnp_type.clone();
650                    match ct {
651                        CapnpType::Text => quote! { #leaf_name: g.#leaf_getter()?.to_str()?.to_string() },
652                        CapnpType::Data => quote! { #leaf_name: g.#leaf_getter()?.to_vec() },
653                        CapnpType::Struct(_) => quote! { #leaf_name: hyprstream_rpc::capnp::FromCapnp::read_from(g.#leaf_getter()?)? },
654                        _ => quote! { #leaf_name: g.#leaf_getter() },
655                    }
656                }).collect();
657                quote! { #capnp_mod::#union_mod::Which::#variant(g) => Self::#variant { #(#leaf_reads,)* }, }
658            }
659        }
660    }).collect();
661
662    quote! {
663        impl hyprstream_rpc::capnp::FromCapnp for #enum_name {
664            type Reader<'a> = #capnp_mod::#capnp_struct::Reader<'a>;
665
666            #[allow(unused_variables)]
667            fn read_from(reader: Self::Reader<'_>) -> anyhow::Result<Self> {
668                Ok(match reader.which()? {
669                    #(#arms)*
670                })
671            }
672        }
673    }
674}
675
676// ─────────────────────────────────────────────────────────────────────────────
677// ToCapnp impl generation
678// ─────────────────────────────────────────────────────────────────────────────
679
680fn generate_to_capnp_impl(
681    type_name: &str,
682    s: &StructDef,
683    resolved: &ResolvedSchema,
684    capnp_mod: &TokenStream,
685    service_name: &str,
686    types_crate: Option<&syn::Path>,
687) -> TokenStream {
688    let data_name = format_ident!("{}", type_name);
689    let capnp_struct = format_ident!("{}", to_capnp_module_name(type_name));
690
691    let field_setters: Vec<TokenStream> = s
692        .non_union_fields()
693        .map(|field| generate_data_field_setter(field, resolved, service_name, types_crate))
694        .collect();
695
696    // Mixed struct: emit the anonymous-union setters by matching on `self.content`.
697    let content_setter = if s.has_union && !s.is_pure_union() {
698        let content_enum = format_ident!("{}Content", type_name);
699        let arms: Vec<TokenStream> = s.union_arms.iter().map(|arm| {
700            let variant = resolved.name(&arm.name).pascal_ident.clone();
701            let arm_snake = &resolved.name(&arm.name).snake;
702            let setter = format_ident!("set_{}", arm_snake);
703            let init = format_ident!("init_{}", arm_snake);
704            match &arm.payload {
705                ArmPayload::Void => quote! { #content_enum::#variant => builder.#setter(()), },
706                ArmPayload::Type(t) => {
707                    let value = quote! { v };
708                    let set = union_arm_value_setter(t, &value, &setter, &init, resolved, capnp_mod, service_name, types_crate);
709                    quote! { #content_enum::#variant(v) => { #set } }
710                }
711                ArmPayload::Group(leaves) => {
712                    let leaf_binds: Vec<TokenStream> = leaves.iter().map(|leaf| {
713                        let leaf_name = resolved.name(&leaf.name).snake_ident.clone();
714                        quote! { #leaf_name }
715                    }).collect();
716                    let leaf_sets: Vec<TokenStream> = leaves.iter().map(|leaf| {
717                        let leaf_snake = &resolved.name(&leaf.name).snake;
718                        let leaf_name = resolved.name(&leaf.name).snake_ident.clone();
719                        let leaf_setter = format_ident!("set_{}", leaf_snake);
720                        let ct = resolved.resolve_type(&leaf.type_name).capnp_type.clone();
721                        match ct {
722                            CapnpType::Text => quote! { __g.#leaf_setter(#leaf_name.as_str()); },
723                            CapnpType::Data => quote! { __g.#leaf_setter(#leaf_name.as_slice()); },
724                            CapnpType::Struct(_) => quote! {
725                                hyprstream_rpc::capnp::ToCapnp::write_to(#leaf_name, &mut __g.reborrow().#leaf_setter());
726                            },
727                            _ => quote! { __g.#leaf_setter(*#leaf_name); },
728                        }
729                    }).collect();
730                    quote! {
731                        #content_enum::#variant { #(#leaf_binds,)* } => {
732                            let mut __g = builder.reborrow().#init();
733                            #(#leaf_sets)*
734                        }
735                    }
736                }
737            }
738        }).collect();
739        quote! {
740            match &self.content {
741                #(#arms)*
742            }
743        }
744    } else {
745        TokenStream::new()
746    };
747
748    quote! {
749        impl hyprstream_rpc::capnp::ToCapnp for #data_name {
750            type Builder<'a> = #capnp_mod::#capnp_struct::Builder<'a>;
751
752            #[allow(unused_variables, unused_mut)]
753            fn write_to(&self, builder: &mut Self::Builder<'_>) {
754                #(#field_setters)*
755                #content_setter
756            }
757        }
758    }
759}
760
761/// Look up a referenced type's origin_file from the structs/enums lists.
762fn lookup_origin_file<'a>(type_name: &str, resolved: &'a ResolvedSchema) -> Option<&'a str> {
763    if let Some(s) = resolved.find_struct(type_name) {
764        return s.origin_file.as_deref();
765    }
766    if let Some(e) = resolved.find_enum(type_name) {
767        return e.origin_file.as_deref();
768    }
769    None
770}
771
772fn generate_data_field_setter(
773    field: &FieldDef,
774    resolved: &ResolvedSchema,
775    service_name: &str,
776    types_crate: Option<&syn::Path>,
777) -> TokenStream {
778    // Check for Option* wrapper struct field
779    if let Some(inner_type_name) = resolved
780        .find_struct(&field.type_name)
781        .and_then(|s| s.option_inner_type())
782    {
783        let rust_name = resolved.name(&field.name).snake_ident.clone();
784        let field_snake = &resolved.name(&field.name).snake;
785        let init_name = format_ident!("init_{}", field_snake);
786        let ct = resolved.resolve_type(inner_type_name).capnp_type.clone();
787        let set_val = match ct {
788            CapnpType::Bool
789            | CapnpType::UInt8
790            | CapnpType::UInt16
791            | CapnpType::UInt32
792            | CapnpType::UInt64
793            | CapnpType::Int8
794            | CapnpType::Int16
795            | CapnpType::Int32
796            | CapnpType::Int64
797            | CapnpType::Float32
798            | CapnpType::Float64 => {
799                quote! { opt.set_some(*__v); }
800            }
801            CapnpType::Text => {
802                quote! { opt.set_some(__v.as_str()); }
803            }
804            CapnpType::Data => {
805                quote! { opt.set_some(__v.as_slice()); }
806            }
807            _ => quote! { let _ = opt; }, // fallback: leave as none
808        };
809        return quote! {
810            if let Some(ref __v) = self.#rust_name {
811                let mut opt = builder.reborrow().#init_name();
812                #set_val
813            }
814        };
815    }
816
817    let inner = generate_data_field_setter_inner(field, resolved, service_name, types_crate);
818    if field.optional {
819        let rust_name = resolved.name(&field.name).snake_ident.clone();
820        // For optional fields, unwrap `self.field` into `__val` and use that in the setter.
821        // The inner setter is generated with `__val` as the value source.
822        quote! { if let Some(ref __val) = self.#rust_name { #inner } }
823    } else {
824        inner
825    }
826}
827
828fn generate_data_field_setter_inner(
829    field: &FieldDef,
830    resolved: &ResolvedSchema,
831    service_name: &str,
832    types_crate: Option<&syn::Path>,
833) -> TokenStream {
834    let rust_name = resolved.name(&field.name).snake_ident.clone();
835    let field_snake = &resolved.name(&field.name).snake;
836    let setter_name = format_ident!("set_{}", field_snake);
837    let ct = resolved.resolve_type(&field.type_name).capnp_type.clone();
838
839    // For optional fields, `__val` is `&T` (from `ref __val` in the if-let).
840    // For non-optional, use `self.field` directly.
841    let (val_owned, val_borrowed) = if field.optional {
842        // __val is &T, so *__val gives T (for Copy), &**__val or __val.as_str() for refs
843        (quote! { *__val }, quote! { __val })
844    } else {
845        (quote! { self.#rust_name }, quote! { &self.#rust_name })
846    };
847
848    match ct {
849        // Field-level `$domainType` newtype over `Text`: write via `.as_str()`.
850        CapnpType::Text if field.domain_type.is_some() => {
851            // Accessor without a leading `&`: optional → `__val` (already `&T`),
852            // non-optional → `self.field`; `.as_str()` borrows in both cases.
853            let val_accessor = if field.optional {
854                quote! { __val }
855            } else {
856                quote! { self.#rust_name }
857            };
858            quote! { builder.#setter_name(#val_accessor.as_str()); }
859        }
860        CapnpType::Text | CapnpType::Data => {
861            quote! { builder.#setter_name(#val_borrowed); }
862        }
863        CapnpType::Bool
864        | CapnpType::UInt8
865        | CapnpType::UInt16
866        | CapnpType::UInt32
867        | CapnpType::UInt64
868        | CapnpType::Int8
869        | CapnpType::Int16
870        | CapnpType::Int32
871        | CapnpType::Int64
872        | CapnpType::Float32
873        | CapnpType::Float64 => {
874            quote! { builder.#setter_name(#val_owned); }
875        }
876        CapnpType::Enum(ref name) => {
877            if let Some(e) = resolved.find_enum(name) {
878                let field_capnp_mod = resolve_capnp_mod(
879                    lookup_origin_file(name, resolved),
880                    service_name,
881                    types_crate,
882                );
883                let enum_rust_name = format_ident!("{}", name);
884                let type_ident = format_ident!("{}", name);
885                // For optional fields, __val is &EnumType, so dereference with *
886                let match_val = if field.optional {
887                    quote! { *__val }
888                } else {
889                    quote! { self.#rust_name }
890                };
891                let match_arms: Vec<TokenStream> = e.variants.iter().map(|(vname, _)| {
892                    let v_pascal = resolved.name(vname).pascal_ident.clone();
893                    quote! { #enum_rust_name::#v_pascal => #field_capnp_mod::#type_ident::#v_pascal }
894                }).collect();
895                quote! {
896                    builder.#setter_name(match #match_val {
897                        #(#match_arms,)*
898                    });
899                }
900            } else {
901                TokenStream::new()
902            }
903        }
904        CapnpType::Struct(_) => {
905            let init_name = format_ident!("init_{}", field_snake);
906            quote! {
907                hyprstream_rpc::capnp::ToCapnp::write_to(#val_borrowed, &mut builder.reborrow().#init_name());
908            }
909        }
910        CapnpType::ListText => {
911            let init_name = format_ident!("init_{}", field_snake);
912            quote! {
913                {
914                    let __list_val = #val_borrowed;
915                    let mut list = builder.reborrow().#init_name(__list_val.len() as u32);
916                    for (i, item) in __list_val.iter().enumerate() {
917                        list.set(i as u32, item.as_str());
918                    }
919                }
920            }
921        }
922        CapnpType::ListData => {
923            let init_name = format_ident!("init_{}", field_snake);
924            quote! {
925                {
926                    let __list_val = #val_borrowed;
927                    let mut list = builder.reborrow().#init_name(__list_val.len() as u32);
928                    for (i, item) in __list_val.iter().enumerate() {
929                        list.set(i as u32, item.as_slice());
930                    }
931                }
932            }
933        }
934        CapnpType::ListPrimitive(ref inner) if inner.is_list() => {
935            // Nested list: List(List(Float32)) → Vec<Vec<f32>>
936            let init_name = format_ident!("init_{}", field_snake);
937            quote! {
938                {
939                    let __list_val = #val_borrowed;
940                    let mut outer = builder.reborrow().#init_name(__list_val.len() as u32);
941                    for (i, inner_vec) in __list_val.iter().enumerate() {
942                        let mut inner_list = outer.reborrow().init(i as u32, inner_vec.len() as u32);
943                        for (j, val) in inner_vec.iter().enumerate() {
944                            inner_list.set(j as u32, *val);
945                        }
946                    }
947                }
948            }
949        }
950        CapnpType::ListPrimitive(_) => {
951            let init_name = format_ident!("init_{}", field_snake);
952            quote! {
953                {
954                    let __list_val = #val_borrowed;
955                    let mut list = builder.reborrow().#init_name(__list_val.len() as u32);
956                    for (i, item) in __list_val.iter().enumerate() {
957                        list.set(i as u32, *item);
958                    }
959                }
960            }
961        }
962        CapnpType::ListStruct(_) => {
963            let init_name = format_ident!("init_{}", field_snake);
964            quote! {
965                {
966                    let __list_val = #val_borrowed;
967                    let mut list = builder.reborrow().#init_name(__list_val.len() as u32);
968                    for (i, item) in __list_val.iter().enumerate() {
969                        hyprstream_rpc::capnp::ToCapnp::write_to(item, &mut list.reborrow().get(i as u32));
970                    }
971                }
972            }
973        }
974        _ => TokenStream::new(),
975    }
976}
977
978// ─────────────────────────────────────────────────────────────────────────────
979// FromCapnp impl generation
980// ─────────────────────────────────────────────────────────────────────────────
981
982fn generate_from_capnp_impl(
983    type_name: &str,
984    s: &StructDef,
985    resolved: &ResolvedSchema,
986    capnp_mod: &TokenStream,
987    service_name: &str,
988    types_crate: Option<&syn::Path>,
989) -> TokenStream {
990    let data_name = format_ident!("{}", type_name);
991    let capnp_struct = format_ident!("{}", to_capnp_module_name(type_name));
992
993    let field_readers: Vec<TokenStream> = s
994        .non_union_fields()
995        .map(|field| generate_data_field_reader(field, resolved, service_name, types_crate))
996        .collect();
997
998    // Mixed struct: read the anonymous union via `which()` into `content`.
999    let content_reader = if s.has_union && !s.is_pure_union() {
1000        let content_enum = format_ident!("{}Content", type_name);
1001        let union_mod = format_ident!("{}", to_capnp_module_name(type_name));
1002        let arms: Vec<TokenStream> = s.union_arms.iter().map(|arm| {
1003            let variant = resolved.name(&arm.name).pascal_ident.clone();
1004            match &arm.payload {
1005                ArmPayload::Void => {
1006                    quote! { #capnp_mod::#union_mod::Which::#variant(()) => #content_enum::#variant, }
1007                }
1008                ArmPayload::Type(t) => {
1009                    let ct = resolved.resolve_type(t).capnp_type.clone();
1010                    match ct {
1011                        CapnpType::Bool | CapnpType::UInt8 | CapnpType::UInt16 | CapnpType::UInt32 | CapnpType::UInt64
1012                        | CapnpType::Int8 | CapnpType::Int16 | CapnpType::Int32 | CapnpType::Int64
1013                        | CapnpType::Float32 | CapnpType::Float64 => {
1014                            quote! { #capnp_mod::#union_mod::Which::#variant(v) => #content_enum::#variant(v), }
1015                        }
1016                        CapnpType::Text => {
1017                            quote! { #capnp_mod::#union_mod::Which::#variant(v) => #content_enum::#variant(v?.to_str()?.to_string()), }
1018                        }
1019                        CapnpType::Data => {
1020                            quote! { #capnp_mod::#union_mod::Which::#variant(v) => #content_enum::#variant(v?.to_vec()), }
1021                        }
1022                        CapnpType::Enum(ref name) => {
1023                            if let Some(e) = resolved.find_enum(name) {
1024                                let field_capnp_mod = resolve_capnp_mod(
1025                                    lookup_origin_file(name, resolved),
1026                                    service_name,
1027                                    types_crate,
1028                                );
1029                                let enum_rust = format_ident!("{}", name);
1030                                let type_ident = format_ident!("{}", name);
1031                                let match_arms: Vec<TokenStream> = e.variants.iter().map(|(vname, _)| {
1032                                    let vp = resolved.name(vname).pascal_ident.clone();
1033                                    quote! { #field_capnp_mod::#type_ident::#vp => #enum_rust::#vp }
1034                                }).collect();
1035                                quote! { #capnp_mod::#union_mod::Which::#variant(v) => #content_enum::#variant(match v? { #(#match_arms,)* }), }
1036                            } else {
1037                                quote! { #capnp_mod::#union_mod::Which::#variant(_) => #content_enum::#variant(Default::default()), }
1038                            }
1039                        }
1040                        CapnpType::Struct(_) => {
1041                            quote! { #capnp_mod::#union_mod::Which::#variant(r) => #content_enum::#variant(hyprstream_rpc::capnp::FromCapnp::read_from(r?)?), }
1042                        }
1043                        _ => quote! { #capnp_mod::#union_mod::Which::#variant(_) => #content_enum::#variant(Default::default()), },
1044                    }
1045                }
1046                ArmPayload::Group(leaves) => {
1047                    let leaf_reads: Vec<TokenStream> = leaves.iter().map(|leaf| {
1048                        let leaf_name = resolved.name(&leaf.name).snake_ident.clone();
1049                        let leaf_getter = format_ident!("get_{}", resolved.name(&leaf.name).snake);
1050                        let ct = resolved.resolve_type(&leaf.type_name).capnp_type.clone();
1051                        match ct {
1052                            CapnpType::Text => quote! { #leaf_name: g.#leaf_getter()?.to_str()?.to_string() },
1053                            CapnpType::Data => quote! { #leaf_name: g.#leaf_getter()?.to_vec() },
1054                            CapnpType::Struct(_) => quote! { #leaf_name: hyprstream_rpc::capnp::FromCapnp::read_from(g.#leaf_getter()?)? },
1055                            _ => quote! { #leaf_name: g.#leaf_getter() },
1056                        }
1057                    }).collect();
1058                    quote! { #capnp_mod::#union_mod::Which::#variant(g) => #content_enum::#variant { #(#leaf_reads,)* }, }
1059                }
1060            }
1061        }).collect();
1062        quote! {
1063            content: match reader.which()? {
1064                #(#arms)*
1065            },
1066        }
1067    } else {
1068        TokenStream::new()
1069    };
1070
1071    quote! {
1072        impl hyprstream_rpc::capnp::FromCapnp for #data_name {
1073            type Reader<'a> = #capnp_mod::#capnp_struct::Reader<'a>;
1074
1075            #[allow(unused_variables)]
1076            fn read_from(reader: Self::Reader<'_>) -> anyhow::Result<Self> {
1077                Ok(Self {
1078                    #(#field_readers)*
1079                    #content_reader
1080                })
1081            }
1082        }
1083    }
1084}
1085
1086fn generate_data_field_reader(
1087    field: &FieldDef,
1088    resolved: &ResolvedSchema,
1089    service_name: &str,
1090    types_crate: Option<&syn::Path>,
1091) -> TokenStream {
1092    let inner = generate_data_field_reader_inner(field, resolved, service_name, types_crate);
1093    if field.optional {
1094        // Wrap in Option: non-default → Some, default → None.
1095        // Only Text and List types use the $optional sentinel convention.
1096        // Numeric/float/enum types use Option* union structs (handled in generate_data_field_reader_inner).
1097        let rust_name = resolved.name(&field.name).snake_ident.clone();
1098        let getter_name = format_ident!("get_{}", resolved.name(&field.name).snake);
1099        let ct = resolved.resolve_type(&field.type_name).capnp_type.clone();
1100        match ct {
1101            // Optional field-level `$domainType` newtype over `Text`: empty → None, else `Some(Type::new(..))`.
1102            CapnpType::Text if field.domain_type.is_some() => {
1103                let dt =
1104                    resolve_field_domain_type(field.domain_type.as_deref().unwrap_or_default());
1105                match field.max_len {
1106                    Some(n) => {
1107                        let n_lit = proc_macro2::Literal::u64_unsuffixed(u64::from(n));
1108                        quote! { #rust_name: {
1109                            let v = reader.#getter_name()?.to_str()?;
1110                            if v.is_empty() { None } else {
1111                                anyhow::ensure!(v.len() <= #n_lit as usize, "text field exceeds $maxLen bound");
1112                                Some(#dt::new(v.to_string()))
1113                            }
1114                        }, }
1115                    }
1116                    None => {
1117                        quote! { #rust_name: { let v = reader.#getter_name()?.to_str()?; if v.is_empty() { None } else { Some(#dt::new(v.to_string())) } }, }
1118                    }
1119                }
1120            }
1121            CapnpType::Data if field.domain_type.is_some() => {
1122                let dt =
1123                    resolve_field_domain_type(field.domain_type.as_deref().unwrap_or_default());
1124                // Bounded decode: the domain type enforces its own wire cap
1125                // BEFORE any owned copy is materialized.
1126                quote! { #rust_name: { let v = reader.#getter_name()?; if v.is_empty() { None } else { Some(<#dt as hyprstream_rpc::sensitive::BoundedWireBytes>::from_wire_bytes(v)?) } }, }
1127            }
1128            CapnpType::Text if field.max_len.is_some() => {
1129                let n_lit =
1130                    proc_macro2::Literal::u64_unsuffixed(u64::from(field.max_len.unwrap_or(0)));
1131                quote! { #rust_name: {
1132                    let v = reader.#getter_name()?.to_str()?;
1133                    if v.is_empty() { None } else {
1134                        anyhow::ensure!(v.len() <= #n_lit as usize, "text field exceeds $maxLen bound");
1135                        Some(v.to_string())
1136                    }
1137                }, }
1138            }
1139            CapnpType::Text => {
1140                quote! { #rust_name: { let v = reader.#getter_name()?.to_str()?; if v.is_empty() { None } else { Some(v.to_string()) } }, }
1141            }
1142            CapnpType::Data => {
1143                if let Some(n) = field.fixed_size {
1144                    let n_usize = n as usize;
1145                    if n <= 32 {
1146                        quote! { #rust_name: {
1147                            let v = reader.#getter_name()?;
1148                            if v.is_empty() {
1149                                None
1150                            } else if v.len() == #n_usize {
1151                                let mut arr = [0u8; #n_usize];
1152                                arr.copy_from_slice(&v[..#n_usize]);
1153                                Some(arr)
1154                            } else {
1155                                anyhow::bail!("optional fixed-size field: expected {} bytes, got {}", #n_usize, v.len());
1156                            }
1157                        }, }
1158                    } else {
1159                        quote! { #rust_name: {
1160                            let v = reader.#getter_name()?;
1161                            if v.is_empty() { None } else { Some(v.to_vec()) }
1162                        }, }
1163                    }
1164                } else {
1165                    quote! { #rust_name: { let v = reader.#getter_name()?; if v.is_empty() { None } else { Some(v.to_vec()) } }, }
1166                }
1167            }
1168            CapnpType::ListText => {
1169                quote! {
1170                    #rust_name: {
1171                        let list = reader.#getter_name()?;
1172                        if list.len() == 0 {
1173                            None
1174                        } else {
1175                            let mut result = Vec::with_capacity(list.len() as usize);
1176                            for i in 0..list.len() {
1177                                result.push(list.get(i)?.to_str()?.to_string());
1178                            }
1179                            Some(result)
1180                        }
1181                    },
1182                }
1183            }
1184            CapnpType::ListData => {
1185                quote! {
1186                    #rust_name: {
1187                        let list = reader.#getter_name()?;
1188                        if list.len() == 0 {
1189                            None
1190                        } else {
1191                            let mut result = Vec::with_capacity(list.len() as usize);
1192                            for i in 0..list.len() {
1193                                result.push(list.get(i)?.to_vec());
1194                            }
1195                            Some(result)
1196                        }
1197                    },
1198                }
1199            }
1200            CapnpType::Bool => {
1201                // Bool $optional: false = None, true = Some(true)
1202                // (Cap'n Proto default for Bool is false, so absent field = false)
1203                let getter_name = format_ident!("get_{}", resolved.name(&field.name).snake);
1204                quote! { #rust_name: { let v = reader.#getter_name(); if v { Some(v) } else { None } }, }
1205            }
1206            CapnpType::Float32 | CapnpType::Float64 => {
1207                // Float $optional: 0.0 = None, non-zero = Some(val)
1208                let getter_name = format_ident!("get_{}", resolved.name(&field.name).snake);
1209                quote! { #rust_name: { let v = reader.#getter_name(); if v != 0.0 { Some(v) } else { None } }, }
1210            }
1211            CapnpType::UInt8
1212            | CapnpType::UInt16
1213            | CapnpType::UInt32
1214            | CapnpType::UInt64
1215            | CapnpType::Int8
1216            | CapnpType::Int16
1217            | CapnpType::Int32
1218            | CapnpType::Int64 => {
1219                // Integer $optional: 0 = None, non-zero = Some(val)
1220                let getter_name = format_ident!("get_{}", resolved.name(&field.name).snake);
1221                quote! { #rust_name: { let v = reader.#getter_name(); if v != 0 { Some(v) } else { None } }, }
1222            }
1223            CapnpType::Struct(_) | CapnpType::Unknown(_) => {
1224                // Struct $optional: read and wrap in Some unconditionally.
1225                // Cap'n Proto struct fields always have a reader, so absence is represented as Default.
1226                quote! { #rust_name: Some(hyprstream_rpc::capnp::FromCapnp::read_from(reader.#getter_name()?)?), }
1227            }
1228            _ => inner, // fall through
1229        }
1230    } else {
1231        inner
1232    }
1233}
1234
1235fn generate_data_field_reader_inner(
1236    field: &FieldDef,
1237    resolved: &ResolvedSchema,
1238    service_name: &str,
1239    types_crate: Option<&syn::Path>,
1240) -> TokenStream {
1241    let rust_name = resolved.name(&field.name).snake_ident.clone();
1242    let getter_name = format_ident!("get_{}", resolved.name(&field.name).snake);
1243    let ct = resolved.resolve_type(&field.type_name).capnp_type.clone();
1244
1245    // Check for Option* wrapper struct field
1246    if let Some(inner_type_name) = resolved
1247        .find_struct(&field.type_name)
1248        .and_then(|s| s.option_inner_type())
1249    {
1250        let capnp_opt_mod = resolve_capnp_mod(
1251            resolved
1252                .find_struct(&field.type_name)
1253                .and_then(|s| s.origin_file.as_deref()),
1254            service_name,
1255            types_crate,
1256        );
1257        let type_mod = format_ident!("{}", to_capnp_module_name(&field.type_name));
1258        let inner_ct = resolved.resolve_type(inner_type_name).capnp_type.clone();
1259        // For Text inner type, getter returns Result<text::Reader>
1260        let some_expr = match inner_ct {
1261            CapnpType::Text => quote! { v.to_str()?.to_string() },
1262            CapnpType::Enum(ref enum_name) => {
1263                // Convert capnp enum value to Rust enum
1264                if let Some(e) = resolved.find_enum(enum_name) {
1265                    let enum_type_ident = format_ident!("{}", enum_name);
1266                    let rust_enum_ident = format_ident!("{}", enum_name);
1267                    let field_capnp_mod = resolve_capnp_mod(
1268                        lookup_origin_file(enum_name, resolved),
1269                        service_name,
1270                        types_crate,
1271                    );
1272                    let match_arms: Vec<TokenStream> = e.variants.iter().map(|(vname, _)| {
1273                        let v_pascal = resolved.name(vname).pascal_ident.clone();
1274                        quote! { #field_capnp_mod::#enum_type_ident::#v_pascal => #rust_enum_ident::#v_pascal }
1275                    }).collect();
1276                    // v is Result<CapnpEnum, NotInSchema> — unwrap with `?` before matching
1277                    quote! { match v? { #(#match_arms,)* _ => Default::default() } }
1278                } else {
1279                    quote! { Default::default() }
1280                }
1281            }
1282            _ => quote! { v },
1283        };
1284        return quote! {
1285            #rust_name: {
1286                let opt = reader.#getter_name()?;
1287                match opt.which()? {
1288                    #capnp_opt_mod::#type_mod::Which::None(()) => None,
1289                    #capnp_opt_mod::#type_mod::Which::Some(v) => Some(#some_expr),
1290                }
1291            },
1292        };
1293    }
1294
1295    match ct {
1296        CapnpType::Void => quote! { #rust_name: (), },
1297        // Field-level byte newtypes retain their redacted Debug implementation.
1298        // Bounded decode: the domain type enforces its own wire cap BEFORE any
1299        // owned copy is materialized (Sol finding: checkMediated evidence was
1300        // copied ahead of the 64 KiB verification bound).
1301        CapnpType::Data if field.domain_type.is_some() => {
1302            let dt = resolve_field_domain_type(field.domain_type.as_deref().unwrap_or_default());
1303            quote! { #rust_name: <#dt as hyprstream_rpc::sensitive::BoundedWireBytes>::from_wire_bytes(reader.#getter_name()?)?, }
1304        }
1305        // Field-level `$domainType` newtype over `Text`: read via `Type::new(String)`.
1306        // `$maxLen(N)` bounds the decoded value at the borrowed reader, before
1307        // any owned String is allocated (bounded preallocation).
1308        CapnpType::Text if field.domain_type.is_some() => {
1309            let dt = resolve_field_domain_type(field.domain_type.as_deref().unwrap_or_default());
1310            match field.max_len {
1311                Some(n) => {
1312                    let n_lit = proc_macro2::Literal::u64_unsuffixed(u64::from(n));
1313                    quote! { #rust_name: {
1314                        let v = reader.#getter_name()?.to_str()?;
1315                        anyhow::ensure!(v.len() <= #n_lit as usize, "text field exceeds $maxLen bound");
1316                        #dt::new(v.to_string())
1317                    }, }
1318                }
1319                None => {
1320                    quote! { #rust_name: #dt::new(reader.#getter_name()?.to_str()?.to_string()), }
1321                }
1322            }
1323        }
1324        CapnpType::Text if field.max_len.is_some() => {
1325            let n = field.max_len.unwrap_or(0);
1326            let n_lit = proc_macro2::Literal::u64_unsuffixed(u64::from(n));
1327            quote! { #rust_name: {
1328                let v = reader.#getter_name()?.to_str()?;
1329                anyhow::ensure!(v.len() <= #n_lit as usize, "text field exceeds $maxLen bound");
1330                v.to_string()
1331            }, }
1332        }
1333        CapnpType::Text => quote! { #rust_name: reader.#getter_name()?.to_str()?.to_string(), },
1334        CapnpType::Data if field.fixed_size.is_some() => {
1335            let n = field.fixed_size.unwrap_or(0);
1336            let n_usize = n as usize;
1337            let n_lit = proc_macro2::Literal::usize_unsuffixed(n_usize);
1338            let field_name_str = field.name.as_str();
1339            if n <= 32 {
1340                quote! {
1341                    #rust_name: {
1342                        let data = reader.#getter_name()?;
1343                        // A null/empty Cap'n Proto pointer is the wire default
1344                        // for an absent fixed-size field. Preserve that as the
1345                        // all-zero Rust default so optional higher-level
1346                        // evidence (such as a resolver witness) can fail closed
1347                        // at its policy boundary instead of making unrelated
1348                        // legacy records undecodable.
1349                        if data.is_empty() {
1350                            [0u8; #n_lit]
1351                        } else if data.len() != #n_lit {
1352                            anyhow::bail!(
1353                                "{}: expected {} bytes, got {}",
1354                                #field_name_str, #n_lit, data.len()
1355                            );
1356                        } else {
1357                            let mut arr = [0u8; #n_lit];
1358                            arr.copy_from_slice(data);
1359                            arr
1360                        }
1361                    },
1362                }
1363            } else {
1364                // N > 32: struct uses Vec<u8>, validate length
1365                quote! {
1366                    #rust_name: {
1367                        let data = reader.#getter_name()?;
1368                        if data.is_empty() {
1369                            Vec::new()
1370                        } else if data.len() != #n_lit {
1371                            anyhow::bail!(
1372                                "{}: expected {} bytes, got {}",
1373                                #field_name_str, #n_lit, data.len()
1374                            );
1375                        } else {
1376                            data.to_vec()
1377                        }
1378                    },
1379                }
1380            }
1381        }
1382        CapnpType::Data => quote! { #rust_name: reader.#getter_name()?.to_vec(), },
1383        CapnpType::Bool
1384        | CapnpType::UInt8
1385        | CapnpType::UInt16
1386        | CapnpType::UInt32
1387        | CapnpType::UInt64
1388        | CapnpType::Int8
1389        | CapnpType::Int16
1390        | CapnpType::Int32
1391        | CapnpType::Int64
1392        | CapnpType::Float32
1393        | CapnpType::Float64 => {
1394            quote! { #rust_name: reader.#getter_name(), }
1395        }
1396        CapnpType::Enum(ref name) => {
1397            if let Some(e) = resolved.find_enum(name) {
1398                let field_capnp_mod = resolve_capnp_mod(
1399                    lookup_origin_file(name, resolved),
1400                    service_name,
1401                    types_crate,
1402                );
1403                let enum_rust_name = format_ident!("{}", name);
1404                let type_ident = format_ident!("{}", name);
1405                let match_arms: Vec<TokenStream> = e.variants.iter().map(|(vname, _)| {
1406                    let v_pascal = resolved.name(vname).pascal_ident.clone();
1407                    quote! { #field_capnp_mod::#type_ident::#v_pascal => #enum_rust_name::#v_pascal }
1408                }).collect();
1409                quote! {
1410                    #rust_name: match reader.#getter_name()? {
1411                        #(#match_arms,)*
1412                        _ => Default::default(),
1413                    },
1414                }
1415            } else {
1416                quote! { #rust_name: Default::default(), }
1417            }
1418        }
1419        CapnpType::Struct(_) => {
1420            quote! {
1421                #rust_name: hyprstream_rpc::capnp::FromCapnp::read_from(reader.#getter_name()?)?,
1422            }
1423        }
1424        CapnpType::ListText => {
1425            quote! {
1426                #rust_name: {
1427                    let list = reader.#getter_name()?;
1428                    let mut result = Vec::with_capacity(list.len() as usize);
1429                    for i in 0..list.len() {
1430                        result.push(list.get(i)?.to_str()?.to_string());
1431                    }
1432                    result
1433                },
1434            }
1435        }
1436        CapnpType::ListData => {
1437            quote! {
1438                #rust_name: {
1439                    let list = reader.#getter_name()?;
1440                    let mut result = Vec::with_capacity(list.len() as usize);
1441                    for i in 0..list.len() {
1442                        result.push(list.get(i)?.to_vec());
1443                    }
1444                    result
1445                },
1446            }
1447        }
1448        CapnpType::ListPrimitive(ref inner) if inner.is_list() => {
1449            // Nested list: List(List(Float32)) → Vec<Vec<f32>>
1450            quote! {
1451                #rust_name: {
1452                    let outer_list = reader.#getter_name()?;
1453                    let mut result = Vec::with_capacity(outer_list.len() as usize);
1454                    for i in 0..outer_list.len() {
1455                        let inner_list = outer_list.get(i)?;
1456                        result.push(inner_list.iter().collect());
1457                    }
1458                    result
1459                },
1460            }
1461        }
1462        CapnpType::ListPrimitive(_) => {
1463            quote! {
1464                #rust_name: reader.#getter_name()?.iter().collect(),
1465            }
1466        }
1467        CapnpType::ListStruct(_) => {
1468            quote! {
1469                #rust_name: {
1470                    let list = reader.#getter_name()?;
1471                    let mut result = Vec::with_capacity(list.len() as usize);
1472                    for i in 0..list.len() {
1473                        result.push(hyprstream_rpc::capnp::FromCapnp::read_from(list.get(i))?);
1474                    }
1475                    result
1476                },
1477            }
1478        }
1479        _ => quote! { #rust_name: Default::default(), },
1480    }
1481}
1482
1483#[cfg(test)]
1484#[allow(clippy::expect_used, clippy::unwrap_used)]
1485mod field_domain_type_tests {
1486    use super::*;
1487    use crate::resolve::ResolvedSchema;
1488    use crate::schema::types::{FieldDef, FieldSection, ParsedSchema, StructDef};
1489
1490    fn text_field(name: &str, domain_type: Option<&str>) -> FieldDef {
1491        FieldDef {
1492            name: name.into(),
1493            type_name: "Text".into(),
1494            description: String::new(),
1495            fixed_size: None,
1496            max_len: None,
1497            optional: false,
1498            slot_offset: 0,
1499            section: FieldSection::Pointer,
1500            discriminant_value: 0xFFFF,
1501            serde_rename: None,
1502            domain_type: domain_type.map(String::from),
1503        }
1504    }
1505
1506    fn data_only_schema(s: StructDef) -> ParsedSchema {
1507        ParsedSchema {
1508            request_variants: vec![],
1509            response_variants: vec![],
1510            structs: vec![s],
1511            scoped_clients: vec![],
1512            enums: vec![],
1513            request_struct: None,
1514            response_struct: None,
1515        }
1516    }
1517
1518    /// A field carrying `$domainType("hyprstream_rpc::identity::Did")` must emit the newtype
1519    /// as the field's Rust type, write via `.as_str()`, and read via `Did::new(...)` — while a
1520    /// sibling plain `Text` field stays a `String`.
1521    #[test]
1522    fn field_level_domain_type_emits_newtype() {
1523        let s = StructDef {
1524            name: "Sample".into(),
1525            fields: vec![
1526                text_field("serviceDid", Some("hyprstream_rpc::identity::Did")),
1527                text_field("plain", None),
1528            ],
1529            has_union: false,
1530            domain_type: None,
1531            origin_file: None,
1532            data_words: 0,
1533            pointer_words: 2,
1534            discriminant_count: 0,
1535            discriminant_offset: 0,
1536            union_arms: vec![],
1537        };
1538        let schema = data_only_schema(s);
1539        let resolved = ResolvedSchema::from(&schema);
1540        let out = generate_data_structs(&resolved, "discovery", None).to_string();
1541
1542        // Struct field uses the newtype, not String (TokenStream spaces out `::`).
1543        assert!(
1544            out.contains("service_did : hyprstream_rpc :: identity :: Did"),
1545            "expected Did-typed field, got:\n{out}"
1546        );
1547        // ToCapnp writes the newtype via `.as_str()`.
1548        assert!(
1549            out.contains("set_service_did") && out.contains("as_str ()"),
1550            "expected `.as_str()` write for domain field, got:\n{out}"
1551        );
1552        // FromCapnp reads via `Did::new(...)`.
1553        assert!(
1554            out.contains("hyprstream_rpc :: identity :: Did :: new"),
1555            "expected `Did::new(...)` read for domain field, got:\n{out}"
1556        );
1557        // The sibling plain Text field stays a String.
1558        assert!(
1559            out.contains("plain : String"),
1560            "expected plain Text field to remain String, got:\n{out}"
1561        );
1562    }
1563
1564    #[test]
1565    fn data_domain_type_handles_required_and_optional_sensitive_bytes() {
1566        for optional in [false, true] {
1567            let mut field = text_field(
1568                "evidence",
1569                Some("hyprstream_rpc::sensitive::SensitiveBytes"),
1570            );
1571            field.type_name = "Data".into();
1572            field.optional = optional;
1573            let schema = data_only_schema(StructDef {
1574                name: "Evidence".into(),
1575                fields: vec![field],
1576                has_union: false,
1577                domain_type: None,
1578                origin_file: None,
1579                data_words: 0,
1580                pointer_words: 1,
1581                discriminant_count: 0,
1582                discriminant_offset: 0,
1583                union_arms: vec![],
1584            });
1585            let out =
1586                generate_data_structs(&ResolvedSchema::from(&schema), "policy", None).to_string();
1587            let expected = if optional {
1588                "evidence : Option < hyprstream_rpc :: sensitive :: SensitiveBytes >"
1589            } else {
1590                "evidence : hyprstream_rpc :: sensitive :: SensitiveBytes"
1591            };
1592            assert!(out.contains(expected), "wrong field type: {out}");
1593            // The generated reader now decodes Data domain types through the
1594            // BoundedWireBytes cap (owned copy only after the bound check).
1595            assert!(
1596                out.contains("BoundedWireBytes") && out.contains("from_wire_bytes"),
1597                "missing bounded wire decode: {out}"
1598            );
1599            assert!(out.contains("set_evidence"), "missing wire writer: {out}");
1600            if optional {
1601                assert!(
1602                    out.contains("is_empty"),
1603                    "missing absent-data sentinel: {out}"
1604                );
1605            }
1606        }
1607    }
1608
1609    /// Struct-level `$domainType` must keep its existing behavior (it does not turn the
1610    /// struct's own fields into newtypes — only field-level annotations do).
1611    #[test]
1612    fn struct_level_domain_type_unaffected() {
1613        let s = StructDef {
1614            name: "Wrapped".into(),
1615            fields: vec![text_field("value", None)],
1616            has_union: false,
1617            domain_type: Some("some::DomainType".into()),
1618            origin_file: None,
1619            data_words: 0,
1620            pointer_words: 1,
1621            discriminant_count: 0,
1622            discriminant_offset: 0,
1623            union_arms: vec![],
1624        };
1625        let schema = data_only_schema(s);
1626        let resolved = ResolvedSchema::from(&schema);
1627        let out = generate_data_structs(&resolved, "discovery", None).to_string();
1628        // Field without a field-level annotation stays a String regardless of struct-level $domainType.
1629        assert!(out.contains("value : String"), "got:\n{out}");
1630    }
1631}