1use proc_macro::TokenStream;
2use quote::{format_ident, quote};
3use std::mem;
4use syn::{
5 parse_macro_input, parse_quote, spanned::Spanned as _, AttributeArgs, FnArg, ItemFn, Lit, Meta,
6 NestedMeta, Type,
7};
8
9#[proc_macro_attribute]
10pub fn test(args: TokenStream, function: TokenStream) -> TokenStream {
11 let mut namespace = format_ident!("gpui");
12
13 let args = syn::parse_macro_input!(args as AttributeArgs);
14 let mut max_retries = 0;
15 let mut num_iterations = 1;
16 let mut starting_seed = 0;
17
18 for arg in args {
19 match arg {
20 NestedMeta::Meta(Meta::Path(name))
21 if name.get_ident().map_or(false, |n| n == "self") =>
22 {
23 namespace = format_ident!("crate");
24 }
25 NestedMeta::Meta(Meta::NameValue(meta)) => {
26 let key_name = meta.path.get_ident().map(|i| i.to_string());
27 let result = (|| {
28 match key_name.as_ref().map(String::as_str) {
29 Some("retries") => max_retries = parse_int(&meta.lit)?,
30 Some("iterations") => num_iterations = parse_int(&meta.lit)?,
31 Some("seed") => starting_seed = parse_int(&meta.lit)?,
32 _ => {
33 return Err(TokenStream::from(
34 syn::Error::new(meta.path.span(), "invalid argument")
35 .into_compile_error(),
36 ))
37 }
38 }
39 Ok(())
40 })();
41
42 if let Err(tokens) = result {
43 return tokens;
44 }
45 }
46 other => {
47 return TokenStream::from(
48 syn::Error::new_spanned(other, "invalid argument").into_compile_error(),
49 )
50 }
51 }
52 }
53
54 let mut inner_fn = parse_macro_input!(function as ItemFn);
55 if max_retries > 0 && num_iterations > 1 {
56 return TokenStream::from(
57 syn::Error::new_spanned(inner_fn, "retries and randomized iterations can't be mixed")
58 .into_compile_error(),
59 );
60 }
61 let inner_fn_attributes = mem::take(&mut inner_fn.attrs);
62 let inner_fn_name = format_ident!("_{}", inner_fn.sig.ident);
63 let outer_fn_name = mem::replace(&mut inner_fn.sig.ident, inner_fn_name.clone());
64
65 let mut outer_fn: ItemFn = if inner_fn.sig.asyncness.is_some() {
66 // Pass to the test function the number of app contexts that it needs,
67 // based on its parameter list.
68 let mut cx_vars = proc_macro2::TokenStream::new();
69 let mut cx_teardowns = proc_macro2::TokenStream::new();
70 let mut inner_fn_args = proc_macro2::TokenStream::new();
71 for (ix, arg) in inner_fn.sig.inputs.iter().enumerate() {
72 if let FnArg::Typed(arg) = arg {
73 if let Type::Path(ty) = &*arg.ty {
74 let last_segment = ty.path.segments.last();
75 match last_segment.map(|s| s.ident.to_string()).as_deref() {
76 Some("StdRng") => {
77 inner_fn_args.extend(quote!(rand::SeedableRng::seed_from_u64(seed),));
78 }
79 Some("bool") => {
80 inner_fn_args.extend(quote!(is_last_iteration,));
81 }
82 _ => {
83 return TokenStream::from(
84 syn::Error::new_spanned(arg, "invalid argument")
85 .into_compile_error(),
86 )
87 }
88 }
89 } else if let Type::Reference(ty) = &*arg.ty {
90 match &*ty.elem {
91 Type::Path(ty) => {
92 let last_segment = ty.path.segments.last();
93 match last_segment.map(|s| s.ident.to_string()).as_deref() {
94 Some("TestAppContext") => {
95 let first_entity_id = ix * 100_000;
96 let cx_varname = format_ident!("cx_{}", ix);
97 cx_vars.extend(quote!(
98 let mut #cx_varname = #namespace::TestAppContext::new(
99 foreground_platform.clone(),
100 cx.platform().clone(),
101 deterministic.build_foreground(#ix),
102 deterministic.build_background(),
103 cx.font_cache().clone(),
104 cx.leak_detector(),
105 #first_entity_id,
106 );
107 ));
108 cx_teardowns.extend(quote!(
109 #cx_varname.update(|cx| cx.remove_all_windows());
110 deterministic.run_until_parked();
111 #cx_varname.update(|_| {}); // flush effects
112 ));
113 inner_fn_args.extend(quote!(&mut #cx_varname,));
114 }
115 _ => {
116 return TokenStream::from(
117 syn::Error::new_spanned(arg, "invalid argument")
118 .into_compile_error(),
119 )
120 }
121 }
122 }
123 _ => {
124 return TokenStream::from(
125 syn::Error::new_spanned(arg, "invalid argument")
126 .into_compile_error(),
127 )
128 }
129 }
130 } else {
131 return TokenStream::from(
132 syn::Error::new_spanned(arg, "invalid argument").into_compile_error(),
133 );
134 }
135 } else {
136 return TokenStream::from(
137 syn::Error::new_spanned(arg, "invalid argument").into_compile_error(),
138 );
139 }
140 }
141
142 parse_quote! {
143 #[test]
144 fn #outer_fn_name() {
145 #inner_fn
146
147 #namespace::test::run_test(
148 #num_iterations as u64,
149 #starting_seed as u64,
150 #max_retries,
151 &mut |cx, foreground_platform, deterministic, seed, is_last_iteration| {
152 #cx_vars
153 cx.foreground().run(#inner_fn_name(#inner_fn_args));
154 #cx_teardowns
155 }
156 );
157 }
158 }
159 } else {
160 let mut inner_fn_args = proc_macro2::TokenStream::new();
161 for arg in inner_fn.sig.inputs.iter() {
162 if let FnArg::Typed(arg) = arg {
163 if let Type::Path(ty) = &*arg.ty {
164 let last_segment = ty.path.segments.last();
165 match last_segment.map(|s| s.ident.to_string()).as_deref() {
166 Some("StdRng") => {
167 inner_fn_args.extend(quote!(rand::SeedableRng::seed_from_u64(seed),));
168 }
169 Some("bool") => {
170 inner_fn_args.extend(quote!(is_last_iteration,));
171 }
172 _ => {}
173 }
174 } else {
175 inner_fn_args.extend(quote!(cx,));
176 }
177 } else {
178 return TokenStream::from(
179 syn::Error::new_spanned(arg, "invalid argument").into_compile_error(),
180 );
181 }
182 }
183
184 parse_quote! {
185 #[test]
186 fn #outer_fn_name() {
187 #inner_fn
188
189 #namespace::test::run_test(
190 #num_iterations as u64,
191 #starting_seed as u64,
192 #max_retries,
193 &mut |cx, _, _, seed, is_last_iteration| #inner_fn_name(#inner_fn_args)
194 );
195 }
196 }
197 };
198 outer_fn.attrs.extend(inner_fn_attributes);
199
200 TokenStream::from(quote!(#outer_fn))
201}
202
203fn parse_int(literal: &Lit) -> Result<usize, TokenStream> {
204 let result = if let Lit::Int(int) = &literal {
205 int.base10_parse()
206 } else {
207 Err(syn::Error::new(literal.span(), "must be an integer"))
208 };
209
210 result.map_err(|err| TokenStream::from(err.into_compile_error()))
211}