1use 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
11fn resolve_field_domain_type(domain_path: &str) -> TokenStream {
18 domain_path.parse().unwrap_or_else(|_| quote! { String })
19}
20
21fn 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
35pub 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 for e in &resolved.raw.enums {
45 tokens.extend(generate_enum_type(e, resolved));
46 }
47
48 const SERVICE_MODULES: &[&str] = &["inference", "model", "registry", "policy", "worker", "mcp"];
52
53 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 if type_name.contains('.') {
72 continue;
73 }
74 if let Some(s) = resolved.find_struct(type_name) {
75 if s.option_inner_type().is_some() {
77 continue;
78 }
79
80 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 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)] 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 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 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 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 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 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
268fn 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
354fn arm_payload_type_tokens(type_name: &str, resolved: &ResolvedSchema) -> TokenStream {
360 rust_type_tokens(&resolved.resolve_type(type_name).rust_owned)
361}
362
363fn 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 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 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
451fn 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
517fn 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
586fn 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 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 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
676fn 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 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
761fn 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 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; }, };
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 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 let (val_owned, val_borrowed) = if field.optional {
842 (quote! { *__val }, quote! { __val })
844 } else {
845 (quote! { self.#rust_name }, quote! { &self.#rust_name })
846 };
847
848 match ct {
849 CapnpType::Text if field.domain_type.is_some() => {
851 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 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 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
978fn 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 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 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 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 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 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 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 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 quote! { #rust_name: Some(hyprstream_rpc::capnp::FromCapnp::read_from(reader.#getter_name()?)?), }
1227 }
1228 _ => inner, }
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 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 let some_expr = match inner_ct {
1261 CapnpType::Text => quote! { v.to_str()?.to_string() },
1262 CapnpType::Enum(ref enum_name) => {
1263 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 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 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 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 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 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 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 #[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 assert!(
1544 out.contains("service_did : hyprstream_rpc :: identity :: Did"),
1545 "expected Did-typed field, got:\n{out}"
1546 );
1547 assert!(
1549 out.contains("set_service_did") && out.contains("as_str ()"),
1550 "expected `.as_str()` write for domain field, got:\n{out}"
1551 );
1552 assert!(
1554 out.contains("hyprstream_rpc :: identity :: Did :: new"),
1555 "expected `Did::new(...)` read for domain field, got:\n{out}"
1556 );
1557 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 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 #[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 assert!(out.contains("value : String"), "got:\n{out}");
1630 }
1631}