1#![cfg_attr(test, allow(clippy::unwrap_used))] mod codegen;
9mod entry;
10mod features;
11mod model;
12
13#[cfg(test)]
15mod golden_tests;
16
17pub(crate) const SERVICE_NAME_LEN: usize = 64;
20
21use proc_macro::TokenStream;
22use quote::quote;
23use syn::{Ident, ItemTrait, Type};
24
25use crate::features::Features;
26use crate::model::{ServiceAttr, ServiceModel};
27
28use crate::codegen::{
29 client::{
30 ClientGenInput, ClientMethodGenInput, ClientOnewayGenInput, gen_client_lifecycle,
31 gen_client_method, gen_client_oneway_method, gen_client_struct,
32 },
33 decoder::{DecoderGenInput, DecoderMethod, gen_decoder},
34 json::{
35 JsonGenInput, JsonMethod, gen_json_invoker_impl, gen_json_provider_from_request_fn,
36 gen_json_provider_from_response_fn, gen_json_provider_method,
37 },
38 lifecycle::{LifecycleGenInput, gen_lifecycle},
39 proxy::{
40 ProxyGenInput, ProxyMethodGenInput, ProxyOnewayGenInput, gen_proxy,
41 gen_proxy_blocking_method, gen_proxy_method, gen_proxy_oneway_call,
42 gen_proxy_oneway_method,
43 },
44 server::{ServerGenInput, gen_native_method, gen_native_oneway_method, gen_server},
45};
46
47fn json_methods(model: &ServiceModel) -> Vec<JsonMethod> {
53 model
54 .methods
55 .iter()
56 .map(|method| JsonMethod {
57 fn_name: method.fn_name.clone(),
58 var_name: method.var_name.clone(),
59 arg_names: method.arg_names.clone(),
60 arg_types: method.arg_types.clone(),
61 ok_type: method.ok_type.clone(),
62 err_type: method.err_type.clone(),
63 oneway: method.oneway,
64 })
65 .collect()
66}
67
68#[proc_macro_attribute]
137pub fn service(attr: TokenStream, item: TokenStream) -> TokenStream {
138 expand_service_with(attr.into(), item.into(), Features::from_cfg()).into()
139}
140
141fn expand_service_with(
152 attr: proc_macro2::TokenStream,
153 item: proc_macro2::TokenStream,
154 features: Features,
155) -> proc_macro2::TokenStream {
156 let service_attr = match syn::parse2::<ServiceAttr>(attr) {
157 Ok(service_attr) => service_attr,
158 Err(e) => return e.to_compile_error(),
159 };
160 let mut input_trait = match syn::parse2::<ItemTrait>(item) {
161 Ok(input_trait) => input_trait,
162 Err(e) => return e.to_compile_error(),
163 };
164
165 inject_trait_requirements(&mut input_trait);
166
167 let model = match ServiceModel::read(&service_attr, &input_trait) {
170 Ok(model) => model,
171 Err(e) => return e.to_compile_error(),
172 };
173
174 let blocking = service_attr.blocking;
176 let no_tracing = service_attr.no_tracing;
178 let no_monitoring = service_attr.no_monitoring;
180
181 let trait_name = &model.trait_name;
182 let visibility = &model.visibility;
183 let logical_name_lit = model.logical_name.clone();
184 let group_lit = model.group.clone();
185 let service_version = model.service_version;
186
187 let max_slice_len = match model.max_slice_len {
190 Some(value) => quote! { #value },
191 None => quote! { ice_rpc::codegen::DEFAULT_MAX_SLICE_LEN },
192 };
193
194 let req_enum_name = &model.req_enum_name;
195 let client_name = &model.client_name;
196 let server_name = &model.server_name;
197 let proxy_name = &model.proxy_name;
198 let mode_name = &model.mode_name;
199 let init_default_name = &model.init_default_name;
200
201 let service_ref = quote! { <#proxy_name>::SERVICE };
204 let service_name = quote! { <#proxy_name>::SERVICE_NAME };
206
207 let mut req_variants = Vec::new();
208 let mut client_methods = Vec::new();
209 let mut proxy_blocking_methods = Vec::new();
210 let mut proxy_oneway_calls = Vec::new();
211 let mut server_native_methods = Vec::new();
212 let mut json_provider_methods = Vec::new();
213 let mut node_methods = Vec::new();
214 let mut decoder_methods: Vec<DecoderMethod> = Vec::new();
215
216 for (discriminant, method) in model.numbered_methods() {
218 let fn_name = &method.fn_name;
219 let var_name = &method.var_name;
220 let arg_names: Vec<&Ident> = method.arg_names.iter().collect();
221 let arg_types: Vec<&Type> = method.arg_types.iter().collect();
222
223 req_variants.push(quote! {
225 #var_name { #(#arg_names: #arg_types),* } = #discriminant
226 });
227
228 if method.oneway {
229 client_methods.push(gen_client_oneway_method(&ClientOnewayGenInput {
230 visibility,
231 fn_name,
232 var_name,
233 arg_names: &arg_names,
234 arg_types: &arg_types,
235 req_enum_name,
236 group: &group_lit,
237 service_ref: &service_ref,
238 }));
239
240 server_native_methods.push(gen_native_oneway_method(
241 proxy_name,
242 fn_name,
243 var_name,
244 &arg_names,
245 req_enum_name,
246 no_tracing,
247 ));
248
249 let proxy_oneway_input = ProxyOnewayGenInput {
250 fn_name,
251 arg_names: &arg_names,
252 arg_types: &arg_types,
253 mode_name,
254 visibility,
255 json_provider: features.json,
256 };
257 node_methods.push(gen_proxy_oneway_method(&proxy_oneway_input));
258 proxy_oneway_calls.push(gen_proxy_oneway_call(&proxy_oneway_input));
259 } else {
261 client_methods.push(gen_client_method(&ClientMethodGenInput {
262 visibility,
263 fn_name,
264 var_name,
265 arg_names: &arg_names,
266 arg_types: &arg_types,
267 ok_type: &method.ok_type,
268 err_type: &method.err_type,
269 req_enum_name,
270 group: &group_lit,
271 service_ref: &service_ref,
272 blocking,
273 }));
274
275 server_native_methods.push(gen_native_method(
276 proxy_name,
277 fn_name,
278 var_name,
279 &arg_names,
280 req_enum_name,
281 no_tracing,
282 ));
283
284 let proxy_method_input = ProxyMethodGenInput {
285 fn_name,
286 arg_names: &arg_names,
287 arg_types: &arg_types,
288 output_type: &method.output_type,
289 mode_name,
290 service_ref: &service_ref,
291 service_name: &service_name,
292 visibility,
293 json_provider: features.json,
294 no_tracing,
295 };
296 node_methods.push(gen_proxy_method(&proxy_method_input));
297 if blocking {
298 proxy_blocking_methods.push(gen_proxy_blocking_method(&proxy_method_input));
299 }
300 }
301
302 if features.json {
304 json_provider_methods.push(gen_json_provider_method(
305 proxy_name,
306 fn_name,
307 method.oneway,
308 no_tracing,
309 ));
310 }
311
312 if features.monitoring {
314 decoder_methods.push(DecoderMethod {
315 method_name: method.fn_name.to_string(),
316 var_name: var_name.clone(),
317 arg_names: method.arg_names.clone(),
318 ok_type: method.ok_type.clone(),
319 err_type: method.err_type.clone(),
320 oneway: method.oneway,
321 });
322 }
323 }
324
325 let client_input = ClientGenInput {
326 visibility,
327 client_name,
328 client_methods: &client_methods,
329 };
330 let client_struct = gen_client_struct(&client_input);
331 let client_lifecycle = gen_client_lifecycle(&client_input);
332
333 let server_input = ServerGenInput {
334 trait_name,
335 visibility,
336 server_name,
337 server_native_methods: &server_native_methods,
338 service_ref: &service_ref,
339 };
340 let server_output = gen_server(&server_input);
341
342 let proxy_input = ProxyGenInput {
343 trait_name,
344 visibility,
345 proxy_name,
346 client_name,
347 mode_name,
348 init_default_name,
349 logical_name_lit: &logical_name_lit,
350 group_lit: &group_lit,
351 max_slice_len: &max_slice_len,
352 service_ref: &service_ref,
353 node_methods: &node_methods,
354 blocking_methods: &proxy_blocking_methods,
355 oneway_calls: &proxy_oneway_calls,
356 json_provider: features.json,
357 json_provider_methods: &json_provider_methods,
358 };
359 let proxy_output = gen_proxy(&proxy_input);
360
361 let lifecycle_input = LifecycleGenInput {
362 trait_name,
363 proxy_name,
364 server_name,
365 mode_name,
366 logical_name_lit: &logical_name_lit,
367 group_lit: &group_lit,
368 max_slice_len: &max_slice_len,
369 json_provider: features.json,
370 };
371 let lifecycle_output = gen_lifecycle(&lifecycle_input);
372
373 let json_methods: Vec<JsonMethod> = json_methods(&model);
376 let json_input = JsonGenInput {
377 visibility,
378 proxy_name,
379 req_enum_name,
380 methods: json_methods,
381 };
382 let (json_provider_from_request, json_provider_from_response) = if features.json {
384 (
385 gen_json_provider_from_request_fn(&json_input),
386 gen_json_provider_from_response_fn(&json_input),
387 )
388 } else {
389 (quote! {}, quote! {})
390 };
391
392 let json_invoker = if features.json {
395 gen_json_invoker_impl(&json_input)
396 } else {
397 quote! {}
398 };
399
400 let decoder_output = if features.monitoring {
402 let decoder_name = Ident::new(&format!("{trait_name}Decoder"), trait_name.span());
403 let hidden_channel = no_monitoring.then_some(group_lit.as_str());
407 let decoder_input = DecoderGenInput {
408 visibility,
409 trait_name,
410 req_enum_name,
411 decoder_name: &decoder_name,
412 logical_name_lit: logical_name_lit.as_str(),
413 methods: &decoder_methods,
414 hidden_channel,
415 };
416 gen_decoder(&decoder_input)
417 } else {
418 quote! {}
419 };
420
421 let collision_symbol = syn::Ident::new(
423 &format!("__ICE_RPC_SVC_{}", logical_name_lit.replace('-', "_")),
424 proc_macro2::Span::call_site(),
425 );
426
427 let generated = quote! {
428 #[repr(u8)]
429 #[derive(ice_rpc::codegen::rkyv::Archive, ice_rpc::codegen::rkyv::Deserialize, ice_rpc::codegen::rkyv::Serialize, Debug)]
431 #[rkyv(crate = ice_rpc::codegen::rkyv)]
432 #visibility enum #req_enum_name { #(#req_variants),* }
433
434 impl #proxy_name {
435 #visibility const SERVICE: ice_rpc::codegen::ServiceRef =
439 ice_rpc::codegen::ServiceRef::new(
440 ice_rpc::codegen::service_id_of(#logical_name_lit),
441 #service_version,
442 );
443 }
444
445 #client_struct
446 #client_lifecycle
447
448 #server_output
449
450 #proxy_output
451
452 #lifecycle_output
453
454 #json_provider_from_request
455 #json_provider_from_response
456 #json_invoker
457
458 #decoder_output
459
460 #[doc(hidden)]
461 #[unsafe(no_mangle)]
462 static #collision_symbol: u8 = 0;
463 };
464
465 let generated = codegen::helpers::allow_missing_docs(generated);
467
468 let expanded = quote! {
469 #[allow(unexpected_cfgs)]
470 #input_trait
471
472 #generated
473 };
474
475 expanded
476}
477
478fn inject_trait_requirements(input_trait: &mut ItemTrait) {
484 let already_annotated = input_trait.attrs.iter().any(|attr| {
485 attr.path()
486 .segments
487 .last()
488 .is_some_and(|segment| segment.ident == "async_trait")
489 });
490 if !already_annotated {
491 input_trait
492 .attrs
493 .push(syn::parse_quote! { #[ice_rpc::codegen::async_trait::async_trait] });
494 }
495
496 let present: Vec<String> = input_trait
498 .supertraits
499 .iter()
500 .map(|bound| quote!(#bound).to_string())
501 .collect();
502
503 for required in [quote!(Send), quote!(Sync), quote!('static)] {
504 if !present.contains(&required.to_string()) {
505 input_trait.supertraits.push(syn::parse_quote!(#required));
506 }
507 }
508}
509
510#[proc_macro_attribute]
552pub fn main(attr: TokenStream, item: TokenStream) -> TokenStream {
553 entry::expand_main(attr.into(), item.into())
554 .unwrap_or_else(|e| e.to_compile_error())
555 .into()
556}
557
558#[proc_macro_attribute]
645pub fn payload(attr: TokenStream, item: TokenStream) -> TokenStream {
646 expand_payload(attr.into(), item.into(), Features::from_cfg()).into()
647}
648
649#[derive(Default)]
651struct PayloadOptions {
652 no_debug: bool,
656 display: bool,
660 no_serde: bool,
664}
665
666impl syn::parse::Parse for PayloadOptions {
667 fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
668 let mut options = Self::default();
669 while !input.is_empty() {
670 let ident: Ident = input.parse()?;
671 if ident == "no_debug" {
672 options.no_debug = true;
673 } else if ident == "display" {
674 options.display = true;
675 } else if ident == "no_serde" {
676 options.no_serde = true;
677 } else {
678 return Err(syn::Error::new(
679 ident.span(),
680 format!("unknown parameter `{ident}` for #[ice_rpc::payload]"),
681 ));
682 }
683 if input.is_empty() {
684 break;
685 }
686 input.parse::<syn::Token![,]>()?;
687 }
688 Ok(options)
689 }
690}
691
692fn expand_payload(
695 attr: proc_macro2::TokenStream,
696 item: proc_macro2::TokenStream,
697 features: Features,
698) -> proc_macro2::TokenStream {
699 let options = match syn::parse2::<PayloadOptions>(attr) {
700 Ok(options) => options,
701 Err(error) => return error.to_compile_error(),
702 };
703
704 let parsed = match syn::parse2::<syn::Item>(item.clone()) {
705 Ok(parsed) => parsed,
706 Err(error) => return error.to_compile_error(),
707 };
708
709 let (item_attrs, item_ident, item_generics) = match &parsed {
711 syn::Item::Struct(item) => (&item.attrs, &item.ident, &item.generics),
712 syn::Item::Enum(item) => (&item.attrs, &item.ident, &item.generics),
713 other => {
714 return syn::Error::new_spanned(
715 other,
716 "#[ice_rpc::payload] may only be applied to a struct or an enum",
717 )
718 .to_compile_error();
719 }
720 };
721
722 if item_attrs.iter().any(is_rkyv_crate_attr) {
723 return syn::Error::new_spanned(
724 &parsed,
725 "#[ice_rpc::payload] already sets `#[rkyv(crate = ..)]`; remove the one written on the item",
726 )
727 .to_compile_error();
728 }
729
730 if options.display && options.no_debug {
732 return syn::Error::new_spanned(
733 &parsed,
734 "#[ice_rpc::payload] cannot combine `display` with `no_debug`: the generated `Display` renders through `Debug`",
735 )
736 .to_compile_error();
737 }
738
739 let debug = if options.no_debug || derives_trait(item_attrs, "Debug") {
742 quote! {}
743 } else {
744 quote! { Debug, }
745 };
746
747 let add_serde = features.json
751 && !options.no_serde
752 && !derives_trait(item_attrs, "Serialize")
753 && !derives_trait(item_attrs, "Deserialize");
754
755 let serde_derives = if add_serde {
756 quote! {
757 ice_rpc::codegen::serde::Serialize,
758 ice_rpc::codegen::serde::Deserialize,
759 }
760 } else {
761 quote! {}
762 };
763
764 let serde_crate_attr = if add_serde {
766 quote! { #[serde(crate = "ice_rpc::codegen::serde")] }
767 } else {
768 quote! {}
769 };
770
771 let display = if options.display {
774 let (impl_generics, ty_generics, where_clause) = item_generics.split_for_impl();
775 let mut predicates = where_clause
776 .map(|clause| clause.predicates.clone())
777 .unwrap_or_default();
778 predicates.push(syn::parse_quote!(
779 #item_ident #ty_generics: ::std::fmt::Debug
780 ));
781 quote! {
782 impl #impl_generics ::std::fmt::Display for #item_ident #ty_generics
783 where #predicates
784 {
785 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
786 ::std::fmt::Debug::fmt(self, f)
787 }
788 }
789 }
790 } else {
791 quote! {}
792 };
793
794 quote! {
795 #[derive(
796 ice_rpc::codegen::rkyv::Archive,
797 ice_rpc::codegen::rkyv::Deserialize,
798 ice_rpc::codegen::rkyv::Serialize,
799 #serde_derives
800 #debug
801 )]
802 #[rkyv(crate = ice_rpc::codegen::rkyv)]
803 #serde_crate_attr
804 #item
805 #display
806 }
807}
808
809fn derives_trait(attrs: &[syn::Attribute], trait_name: &str) -> bool {
815 attrs
816 .iter()
817 .filter(|attr| attr.path().is_ident("derive"))
818 .any(|attr| {
819 let mut found = false;
820 let _ = attr.parse_nested_meta(|meta| {
822 if meta
823 .path
824 .segments
825 .last()
826 .is_some_and(|segment| segment.ident == trait_name)
827 {
828 found = true;
829 }
830 Ok(())
831 });
832 found
833 })
834}
835
836fn is_rkyv_crate_attr(attr: &syn::Attribute) -> bool {
839 if !attr.path().is_ident("rkyv") {
840 return false;
841 }
842 let mut found = false;
843 let _ = attr.parse_nested_meta(|meta| {
845 if meta.path.is_ident("crate") {
846 found = true;
847 let _ = meta.value().and_then(|value| value.parse::<syn::Path>());
849 }
850 Ok(())
851 });
852 found
853}
854
855#[cfg(test)]
856mod payload_tests {
857 use super::{Features, expand_payload};
858 use quote::quote;
859
860 fn expand(
866 attr: proc_macro2::TokenStream,
867 item: proc_macro2::TokenStream,
868 ) -> proc_macro2::TokenStream {
869 expand_payload(
870 attr,
871 item,
872 Features {
873 monitoring: false,
874 json: false,
875 },
876 )
877 }
878
879 fn expand_json(
881 attr: proc_macro2::TokenStream,
882 item: proc_macro2::TokenStream,
883 ) -> proc_macro2::TokenStream {
884 expand_payload(
885 attr,
886 item,
887 Features {
888 monitoring: false,
889 json: true,
890 },
891 )
892 }
893
894 fn generated_derivation(out: &proc_macro2::TokenStream) -> String {
897 let rendered = out.to_string();
898 rendered
899 .split("# [rkyv")
900 .next()
901 .unwrap_or_default()
902 .to_string()
903 }
904
905 #[test]
906 fn payload_adds_the_rkyv_derives_and_redirects_the_crate() {
907 let out = expand(
908 quote! {},
909 quote! {
910 #[derive(Debug, Clone)]
911 pub struct Query {
912 pub key: String,
913 }
914 },
915 )
916 .to_string();
917 assert!(
918 out.contains("ice_rpc :: codegen :: rkyv :: Archive"),
919 "{out}"
920 );
921 assert!(
922 out.contains("ice_rpc :: codegen :: rkyv :: Deserialize"),
923 "{out}"
924 );
925 assert!(
926 out.contains("ice_rpc :: codegen :: rkyv :: Serialize"),
927 "{out}"
928 );
929 assert!(
930 out.contains("rkyv (crate = ice_rpc :: codegen :: rkyv)"),
931 "{out}"
932 );
933 assert!(out.contains("derive (Debug , Clone)"), "{out}");
935 assert!(out.contains("pub struct Query"), "{out}");
936 }
937
938 #[test]
939 fn payload_adds_debug_when_the_item_does_not_derive_it() {
940 let out = expand(
941 quote! {},
942 quote! {
943 pub struct Query { pub key: String }
944 },
945 );
946 let generated = generated_derivation(&out);
948 assert!(generated.contains("Debug"), "{out}");
949 }
950
951 #[test]
952 fn payload_keeps_the_items_own_debug_derivation() {
953 let out = expand(
954 quote! {},
955 quote! {
956 #[derive(Debug, Clone)]
957 pub struct Query { pub key: String }
958 },
959 );
960 let generated = generated_derivation(&out);
962 assert!(!generated.contains("Debug"), "{out}");
963 }
964
965 #[test]
966 fn payload_detects_a_fully_qualified_debug_derive() {
967 let out = expand(
968 quote! {},
969 quote! {
970 #[derive(std::fmt::Debug)]
971 pub struct Query { pub key: String }
972 },
973 );
974 let generated = generated_derivation(&out);
975 assert!(!generated.contains("Debug"), "{out}");
976 }
977
978 #[test]
979 fn payload_no_debug_leaves_the_derivation_to_a_hand_written_impl() {
980 let out = expand(
981 quote! { no_debug },
982 quote! {
983 pub struct Point { pub x: i32 }
984 },
985 );
986 let generated = generated_derivation(&out);
987 assert!(!generated.contains("Debug"), "{out}");
988 assert!(
989 generated.contains("ice_rpc :: codegen :: rkyv :: Archive"),
990 "{out}"
991 );
992 }
993
994 #[test]
995 fn payload_display_delegates_to_debug() {
996 let out = expand(
997 quote! { display },
998 quote! {
999 pub enum MyError { NotFound }
1000 },
1001 );
1002 let rendered = out.to_string();
1003 assert!(
1005 rendered.contains(
1006 "impl :: std :: fmt :: Display for MyError where MyError : :: std :: fmt :: Debug"
1007 ),
1008 "{rendered}"
1009 );
1010 assert!(
1011 rendered.contains(":: std :: fmt :: Debug :: fmt (self , f)"),
1012 "{rendered}"
1013 );
1014 assert!(generated_derivation(&out).contains("Debug"), "{rendered}");
1016 }
1017
1018 #[test]
1019 fn payload_display_on_a_generic_type_bounds_the_delegation() {
1020 let out = expand(
1021 quote! { display },
1022 quote! {
1023 pub struct Wrapper<T> { pub inner: T }
1024 },
1025 )
1026 .to_string();
1027 assert!(
1029 out.contains("where Wrapper < T > : :: std :: fmt :: Debug"),
1030 "{out}"
1031 );
1032 }
1033
1034 #[test]
1035 fn payload_refuses_display_combined_with_no_debug() {
1036 let out = expand(
1037 quote! { display, no_debug },
1038 quote! {
1039 pub struct Query { pub key: String }
1040 },
1041 )
1042 .to_string();
1043 assert!(
1044 out.contains("cannot combine `display` with `no_debug`"),
1045 "{out}"
1046 );
1047 }
1048
1049 #[test]
1050 fn payload_refuses_an_unknown_parameter() {
1051 let out = expand(
1052 quote! { debug },
1053 quote! {
1054 pub struct Query { pub key: String }
1055 },
1056 )
1057 .to_string();
1058 assert!(out.contains("unknown parameter `debug`"), "{out}");
1059 }
1060
1061 #[test]
1062 fn payload_works_on_an_enum() {
1063 let out = expand(
1064 quote! {},
1065 quote! {
1066 pub enum Status { Ok, Nok }
1067 },
1068 )
1069 .to_string();
1070 assert!(
1071 out.contains("ice_rpc :: codegen :: rkyv :: Archive"),
1072 "{out}"
1073 );
1074 assert!(out.contains("pub enum Status"), "{out}");
1075 }
1076
1077 #[test]
1078 fn payload_adds_serde_derives_when_the_json_block_is_on() {
1079 let out = expand_json(
1080 quote! {},
1081 quote! {
1082 pub struct Query { pub key: String }
1083 },
1084 )
1085 .to_string();
1086 assert!(
1087 out.contains("ice_rpc :: codegen :: serde :: Serialize"),
1088 "{out}"
1089 );
1090 assert!(
1091 out.contains("ice_rpc :: codegen :: serde :: Deserialize"),
1092 "{out}"
1093 );
1094 assert!(
1096 out.contains(r#"serde (crate = "ice_rpc::codegen::serde")"#),
1097 "{out}"
1098 );
1099 }
1100
1101 #[test]
1102 fn payload_without_the_json_block_adds_no_serde() {
1103 let out = expand(
1104 quote! {},
1105 quote! {
1106 pub struct Query { pub key: String }
1107 },
1108 )
1109 .to_string();
1110 assert!(!out.contains("serde"), "{out}");
1111 }
1112
1113 #[test]
1117 fn payload_keeps_a_serde_derivation_already_written() {
1118 let out = expand_json(
1119 quote! {},
1120 quote! {
1121 #[derive(serde::Serialize, serde::Deserialize)]
1122 pub struct Query { pub key: String }
1123 },
1124 )
1125 .to_string();
1126 assert_eq!(out.matches("serde :: Serialize").count(), 1, "{out}");
1128 assert!(!out.contains("codegen :: serde :: Serialize"), "{out}");
1129 assert!(!out.contains("codegen :: serde :: Deserialize"), "{out}");
1130 assert!(!out.contains("serde (crate = "), "{out}");
1131 }
1132
1133 #[test]
1134 fn payload_no_serde_opts_out() {
1135 let out = expand_json(
1136 quote! { no_serde },
1137 quote! {
1138 pub struct Query { pub key: String }
1139 },
1140 )
1141 .to_string();
1142 assert!(!out.contains("serde"), "{out}");
1143 }
1144
1145 #[test]
1146 fn payload_refuses_a_non_struct_or_enum_item() {
1147 let out = expand(quote! {}, quote! { fn free() {} }).to_string();
1148 assert!(
1149 out.contains("may only be applied to a struct or an enum"),
1150 "{out}"
1151 );
1152 }
1153
1154 #[test]
1155 fn payload_refuses_an_item_that_already_sets_the_rkyv_crate() {
1156 let out = expand(
1157 quote! {},
1158 quote! {
1159 #[rkyv(crate = other::place)]
1160 pub struct Query { pub key: String }
1161 },
1162 )
1163 .to_string();
1164 assert!(out.contains("already sets"), "{out}");
1165 }
1166}
1167
1168#[cfg(test)]
1169mod entry_tests {
1170 use super::entry::expand_main;
1171 use proc_macro2::TokenStream;
1172 use quote::quote;
1173
1174 fn expand(attr: TokenStream, item: TokenStream) -> String {
1175 expand_main(attr, item)
1176 .expect("expansion should succeed")
1177 .to_string()
1178 }
1179
1180 #[test]
1181 fn main_default_uses_the_agnostic_driver() {
1182 let out = expand(
1183 quote! {},
1184 quote! { async fn main() -> Result<(), String> { Ok(()) } },
1185 );
1186 assert!(out.contains("ice_rpc :: rt :: block_on"), "{out}");
1187 assert!(out.contains("ice_rpc :: codegen :: init ()"), "{out}");
1188 assert!(out.contains("-> Result < () , String >"), "{out}");
1189 assert!(
1190 out.starts_with("fn main"),
1191 "the generated main must be sync: {out}"
1192 );
1193 assert!(!out.contains("async fn main"), "{out}");
1194 }
1195
1196 #[test]
1197 fn main_tokio_builds_a_tokio_runtime() {
1198 let out = expand(quote! { tokio }, quote! { async fn main() {} });
1199 assert!(out.contains("new_multi_thread"), "{out}");
1200 assert!(!out.contains("ice_rpc :: rt :: block_on"), "{out}");
1201 }
1202
1203 #[test]
1204 fn main_custom_driver_is_used_verbatim() {
1205 let out = expand(quote! { smol::block_on }, quote! { async fn main() {} });
1206 assert!(out.contains("smol :: block_on"), "{out}");
1207 }
1208
1209 #[test]
1210 fn main_wraps_body_in_an_inner_async_block() {
1211 let out = expand(quote! {}, quote! { async fn main() {} });
1212 let shutdown = out.find("shutdown").expect("shutdown() missing");
1214 let body_await = out.find(". await").expect("body await missing");
1215 assert!(body_await < shutdown, "{out}");
1216 }
1217
1218 #[test]
1219 fn main_rejects_a_synchronous_function() {
1220 let err = expand_main(quote! {}, quote! { fn main() {} }).unwrap_err();
1221 assert!(err.to_string().contains("async fn main"));
1222 }
1223
1224 #[test]
1225 fn main_rt_none_wraps_a_synchronous_main() {
1226 let out = expand(quote! { rt-none }, quote! { fn main() {} });
1227 assert!(out.contains("ice_rpc :: codegen :: init ()"), "{out}");
1228 assert!(out.contains("shutdown_blocking"), "{out}");
1229 assert!(out.starts_with("fn main"), "{out}");
1230 assert!(!out.contains("async"), "{out}");
1232 assert!(!out.contains("block_on"), "{out}");
1233 }
1234
1235 #[test]
1236 fn main_rt_none_rejects_an_async_function() {
1237 let err = expand_main(quote! { rt-none }, quote! { async fn main() {} }).unwrap_err();
1238 assert!(err.to_string().contains("synchronous"), "{err}");
1239 }
1240}
1241
1242#[cfg(test)]
1243mod trait_requirements_tests {
1244 use super::inject_trait_requirements;
1245 use syn::ItemTrait;
1246
1247 #[test]
1248 fn a_bare_trait_gets_the_attribute_and_the_three_bounds() {
1249 let mut item: ItemTrait = syn::parse_quote! { trait Bare {} };
1250 inject_trait_requirements(&mut item);
1251 assert_eq!(item.attrs.len(), 1);
1252 assert_eq!(item.supertraits.len(), 3);
1253 }
1254
1255 #[test]
1256 fn a_trait_that_already_declares_them_keeps_one_copy() {
1257 let mut item: ItemTrait = syn::parse_quote! {
1258 #[async_trait::async_trait]
1259 trait Declared: Send + Sync + 'static {}
1260 };
1261 inject_trait_requirements(&mut item);
1262 let rendered = quote::quote!(#item).to_string();
1264 assert_eq!(
1265 item.attrs.len(),
1266 1,
1267 "the attribute must not be duplicated: {rendered}"
1268 );
1269 assert_eq!(
1270 item.supertraits.len(),
1271 3,
1272 "the bounds must not be duplicated: {rendered}"
1273 );
1274 }
1275
1276 #[test]
1277 fn a_partially_declared_trait_is_completed_in_order() {
1278 let mut item: ItemTrait = syn::parse_quote! { trait Partial: Send {} };
1279 inject_trait_requirements(&mut item);
1280 let rendered = quote::quote!(#item).to_string();
1281 assert!(
1282 rendered.contains("Send + Sync + 'static"),
1283 "the missing bounds must be appended after the declared one: {rendered}"
1284 );
1285 }
1286}