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