]>
Commit | Line | Data |
---|---|---|
1a4d82fc JJ |
1 | // Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT |
2 | // file at the top-level directory of this distribution and at | |
3 | // http://rust-lang.org/COPYRIGHT. | |
4 | // | |
5 | // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or | |
6 | // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license | |
7 | // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your | |
8 | // option. This file may not be copied, modified, or distributed | |
9 | // except according to those terms. | |
10 | ||
11 | // Code that generates a test runner to run all the tests in a crate | |
12 | ||
13 | #![allow(dead_code)] | |
14 | #![allow(unused_imports)] | |
15 | use self::HasTestSignature::*; | |
16 | ||
17 | use std::slice; | |
18 | use std::mem; | |
19 | use std::vec; | |
20 | use ast_util::*; | |
21 | use attr::AttrMetaMethods; | |
22 | use attr; | |
23 | use codemap::{DUMMY_SP, Span, ExpnInfo, NameAndSpan, MacroAttribute}; | |
24 | use codemap; | |
25 | use diagnostic; | |
26 | use config; | |
27 | use ext::base::ExtCtxt; | |
28 | use ext::build::AstBuilder; | |
29 | use ext::expand::ExpansionConfig; | |
30 | use fold::{Folder, MoveMap}; | |
31 | use fold; | |
32 | use owned_slice::OwnedSlice; | |
33 | use parse::token::InternedString; | |
34 | use parse::{token, ParseSess}; | |
35 | use print::pprust; | |
36 | use {ast, ast_util}; | |
37 | use ptr::P; | |
38 | use util::small_vector::SmallVector; | |
39 | ||
c34b1796 | 40 | enum ShouldPanic { |
1a4d82fc JJ |
41 | No, |
42 | Yes(Option<InternedString>), | |
43 | } | |
44 | ||
45 | struct Test { | |
46 | span: Span, | |
47 | path: Vec<ast::Ident> , | |
48 | bench: bool, | |
49 | ignore: bool, | |
c34b1796 | 50 | should_panic: ShouldPanic |
1a4d82fc JJ |
51 | } |
52 | ||
53 | struct TestCtxt<'a> { | |
54 | sess: &'a ParseSess, | |
55 | span_diagnostic: &'a diagnostic::SpanHandler, | |
56 | path: Vec<ast::Ident>, | |
57 | ext_cx: ExtCtxt<'a>, | |
58 | testfns: Vec<Test>, | |
59 | reexport_test_harness_main: Option<InternedString>, | |
60 | is_test_crate: bool, | |
61 | config: ast::CrateConfig, | |
62 | ||
63 | // top-level re-export submodule, filled out after folding is finished | |
64 | toplevel_reexport: Option<ast::Ident>, | |
65 | } | |
66 | ||
67 | // Traverse the crate, collecting all the test functions, eliding any | |
68 | // existing main functions, and synthesizing a main test harness | |
69 | pub fn modify_for_testing(sess: &ParseSess, | |
70 | cfg: &ast::CrateConfig, | |
71 | krate: ast::Crate, | |
72 | span_diagnostic: &diagnostic::SpanHandler) -> ast::Crate { | |
73 | // We generate the test harness when building in the 'test' | |
74 | // configuration, either with the '--test' or '--cfg test' | |
75 | // command line options. | |
c34b1796 | 76 | let should_test = attr::contains_name(&krate.config, "test"); |
1a4d82fc JJ |
77 | |
78 | // Check for #[reexport_test_harness_main = "some_name"] which | |
79 | // creates a `use some_name = __test::main;`. This needs to be | |
80 | // unconditional, so that the attribute is still marked as used in | |
81 | // non-test builds. | |
82 | let reexport_test_harness_main = | |
c34b1796 | 83 | attr::first_attr_value_str_by_name(&krate.attrs, |
1a4d82fc JJ |
84 | "reexport_test_harness_main"); |
85 | ||
86 | if should_test { | |
87 | generate_test_harness(sess, reexport_test_harness_main, krate, cfg, span_diagnostic) | |
88 | } else { | |
89 | strip_test_functions(krate) | |
90 | } | |
91 | } | |
92 | ||
93 | struct TestHarnessGenerator<'a> { | |
94 | cx: TestCtxt<'a>, | |
95 | tests: Vec<ast::Ident>, | |
96 | ||
97 | // submodule name, gensym'd identifier for re-exports | |
98 | tested_submods: Vec<(ast::Ident, ast::Ident)>, | |
99 | } | |
100 | ||
101 | impl<'a> fold::Folder for TestHarnessGenerator<'a> { | |
102 | fn fold_crate(&mut self, c: ast::Crate) -> ast::Crate { | |
103 | let mut folded = fold::noop_fold_crate(c, self); | |
104 | ||
105 | // Add a special __test module to the crate that will contain code | |
106 | // generated for the test harness | |
107 | let (mod_, reexport) = mk_test_module(&mut self.cx); | |
1a4d82fc | 108 | match reexport { |
85aaf69f | 109 | Some(re) => folded.module.items.push(re), |
1a4d82fc JJ |
110 | None => {} |
111 | } | |
85aaf69f | 112 | folded.module.items.push(mod_); |
1a4d82fc JJ |
113 | folded |
114 | } | |
115 | ||
116 | fn fold_item(&mut self, i: P<ast::Item>) -> SmallVector<P<ast::Item>> { | |
117 | let ident = i.ident; | |
118 | if ident.name != token::special_idents::invalid.name { | |
119 | self.cx.path.push(ident); | |
120 | } | |
121 | debug!("current path: {}", | |
85aaf69f | 122 | ast_util::path_name_i(&self.cx.path)); |
1a4d82fc | 123 | |
c34b1796 | 124 | let i = if is_test_fn(&self.cx, &*i) || is_bench_fn(&self.cx, &*i) { |
1a4d82fc | 125 | match i.node { |
62682a34 | 126 | ast::ItemFn(_, ast::Unsafety::Unsafe, _, _, _, _) => { |
1a4d82fc | 127 | let diag = self.cx.span_diagnostic; |
9346a6ac | 128 | panic!(diag.span_fatal(i.span, "unsafe functions cannot be used for tests")); |
1a4d82fc JJ |
129 | } |
130 | _ => { | |
131 | debug!("this is a test function"); | |
132 | let test = Test { | |
133 | span: i.span, | |
134 | path: self.cx.path.clone(), | |
135 | bench: is_bench_fn(&self.cx, &*i), | |
136 | ignore: is_ignored(&*i), | |
c34b1796 | 137 | should_panic: should_panic(&*i) |
1a4d82fc JJ |
138 | }; |
139 | self.cx.testfns.push(test); | |
140 | self.tests.push(i.ident); | |
141 | // debug!("have {} test/bench functions", | |
142 | // cx.testfns.len()); | |
c34b1796 AL |
143 | |
144 | // Make all tests public so we can call them from outside | |
145 | // the module (note that the tests are re-exported and must | |
146 | // be made public themselves to avoid privacy errors). | |
147 | i.map(|mut i| { | |
148 | i.vis = ast::Public; | |
149 | i | |
150 | }) | |
1a4d82fc JJ |
151 | } |
152 | } | |
c34b1796 AL |
153 | } else { |
154 | i | |
155 | }; | |
1a4d82fc JJ |
156 | |
157 | // We don't want to recurse into anything other than mods, since | |
158 | // mods or tests inside of functions will break things | |
159 | let res = match i.node { | |
160 | ast::ItemMod(..) => fold::noop_fold_item(i, self), | |
161 | _ => SmallVector::one(i), | |
162 | }; | |
163 | if ident.name != token::special_idents::invalid.name { | |
164 | self.cx.path.pop(); | |
165 | } | |
166 | res | |
167 | } | |
168 | ||
169 | fn fold_mod(&mut self, m: ast::Mod) -> ast::Mod { | |
170 | let tests = mem::replace(&mut self.tests, Vec::new()); | |
171 | let tested_submods = mem::replace(&mut self.tested_submods, Vec::new()); | |
172 | let mut mod_folded = fold::noop_fold_mod(m, self); | |
173 | let tests = mem::replace(&mut self.tests, tests); | |
174 | let tested_submods = mem::replace(&mut self.tested_submods, tested_submods); | |
175 | ||
176 | // Remove any #[main] from the AST so it doesn't clash with | |
177 | // the one we're going to add. Only if compiling an executable. | |
178 | ||
179 | mod_folded.items = mem::replace(&mut mod_folded.items, vec![]).move_map(|item| { | |
180 | item.map(|ast::Item {id, ident, attrs, node, vis, span}| { | |
181 | ast::Item { | |
182 | id: id, | |
183 | ident: ident, | |
184 | attrs: attrs.into_iter().filter_map(|attr| { | |
185 | if !attr.check_name("main") { | |
186 | Some(attr) | |
187 | } else { | |
188 | None | |
189 | } | |
190 | }).collect(), | |
191 | node: node, | |
192 | vis: vis, | |
193 | span: span | |
194 | } | |
195 | }) | |
196 | }); | |
197 | ||
198 | if !tests.is_empty() || !tested_submods.is_empty() { | |
199 | let (it, sym) = mk_reexport_mod(&mut self.cx, tests, tested_submods); | |
200 | mod_folded.items.push(it); | |
201 | ||
202 | if !self.cx.path.is_empty() { | |
203 | self.tested_submods.push((self.cx.path[self.cx.path.len()-1], sym)); | |
204 | } else { | |
205 | debug!("pushing nothing, sym: {:?}", sym); | |
206 | self.cx.toplevel_reexport = Some(sym); | |
207 | } | |
208 | } | |
209 | ||
210 | mod_folded | |
211 | } | |
212 | } | |
213 | ||
214 | fn mk_reexport_mod(cx: &mut TestCtxt, tests: Vec<ast::Ident>, | |
215 | tested_submods: Vec<(ast::Ident, ast::Ident)>) -> (P<ast::Item>, ast::Ident) { | |
1a4d82fc JJ |
216 | let super_ = token::str_to_ident("super"); |
217 | ||
85aaf69f SL |
218 | let items = tests.into_iter().map(|r| { |
219 | cx.ext_cx.item_use_simple(DUMMY_SP, ast::Public, | |
1a4d82fc | 220 | cx.ext_cx.path(DUMMY_SP, vec![super_, r])) |
85aaf69f | 221 | }).chain(tested_submods.into_iter().map(|(r, sym)| { |
1a4d82fc | 222 | let path = cx.ext_cx.path(DUMMY_SP, vec![super_, r, sym]); |
85aaf69f | 223 | cx.ext_cx.item_use_simple_(DUMMY_SP, ast::Public, r, path) |
1a4d82fc JJ |
224 | })); |
225 | ||
226 | let reexport_mod = ast::Mod { | |
227 | inner: DUMMY_SP, | |
85aaf69f | 228 | items: items.collect(), |
1a4d82fc JJ |
229 | }; |
230 | ||
231 | let sym = token::gensym_ident("__test_reexports"); | |
232 | let it = P(ast::Item { | |
233 | ident: sym.clone(), | |
234 | attrs: Vec::new(), | |
235 | id: ast::DUMMY_NODE_ID, | |
236 | node: ast::ItemMod(reexport_mod), | |
237 | vis: ast::Public, | |
238 | span: DUMMY_SP, | |
239 | }); | |
240 | ||
241 | (it, sym) | |
242 | } | |
243 | ||
244 | fn generate_test_harness(sess: &ParseSess, | |
245 | reexport_test_harness_main: Option<InternedString>, | |
246 | krate: ast::Crate, | |
247 | cfg: &ast::CrateConfig, | |
248 | sd: &diagnostic::SpanHandler) -> ast::Crate { | |
249 | let mut cx: TestCtxt = TestCtxt { | |
250 | sess: sess, | |
251 | span_diagnostic: sd, | |
252 | ext_cx: ExtCtxt::new(sess, cfg.clone(), | |
253 | ExpansionConfig::default("test".to_string())), | |
254 | path: Vec::new(), | |
255 | testfns: Vec::new(), | |
256 | reexport_test_harness_main: reexport_test_harness_main, | |
257 | is_test_crate: is_test_crate(&krate), | |
258 | config: krate.config.clone(), | |
259 | toplevel_reexport: None, | |
260 | }; | |
261 | ||
262 | cx.ext_cx.bt_push(ExpnInfo { | |
263 | call_site: DUMMY_SP, | |
264 | callee: NameAndSpan { | |
265 | name: "test".to_string(), | |
266 | format: MacroAttribute, | |
c34b1796 AL |
267 | span: None, |
268 | allow_internal_unstable: false, | |
1a4d82fc JJ |
269 | } |
270 | }); | |
271 | ||
272 | let mut fold = TestHarnessGenerator { | |
273 | cx: cx, | |
274 | tests: Vec::new(), | |
275 | tested_submods: Vec::new(), | |
276 | }; | |
277 | let res = fold.fold_crate(krate); | |
278 | fold.cx.ext_cx.bt_pop(); | |
279 | return res; | |
280 | } | |
281 | ||
282 | fn strip_test_functions(krate: ast::Crate) -> ast::Crate { | |
283 | // When not compiling with --test we should not compile the | |
284 | // #[test] functions | |
285 | config::strip_items(krate, |attrs| { | |
85aaf69f SL |
286 | !attr::contains_name(&attrs[..], "test") && |
287 | !attr::contains_name(&attrs[..], "bench") | |
1a4d82fc JJ |
288 | }) |
289 | } | |
290 | ||
85aaf69f SL |
291 | /// Craft a span that will be ignored by the stability lint's |
292 | /// call to codemap's is_internal check. | |
293 | /// The expanded code calls some unstable functions in the test crate. | |
294 | fn ignored_span(cx: &TestCtxt, sp: Span) -> Span { | |
295 | let info = ExpnInfo { | |
296 | call_site: DUMMY_SP, | |
297 | callee: NameAndSpan { | |
298 | name: "test".to_string(), | |
299 | format: MacroAttribute, | |
c34b1796 AL |
300 | span: None, |
301 | allow_internal_unstable: true, | |
85aaf69f SL |
302 | } |
303 | }; | |
62682a34 | 304 | let expn_id = cx.sess.codemap().record_expansion(info); |
85aaf69f SL |
305 | let mut sp = sp; |
306 | sp.expn_id = expn_id; | |
307 | return sp; | |
308 | } | |
309 | ||
1a4d82fc JJ |
310 | #[derive(PartialEq)] |
311 | enum HasTestSignature { | |
312 | Yes, | |
313 | No, | |
314 | NotEvenAFunction, | |
315 | } | |
316 | ||
317 | ||
318 | fn is_test_fn(cx: &TestCtxt, i: &ast::Item) -> bool { | |
c34b1796 | 319 | let has_test_attr = attr::contains_name(&i.attrs, "test"); |
1a4d82fc JJ |
320 | |
321 | fn has_test_signature(i: &ast::Item) -> HasTestSignature { | |
322 | match &i.node { | |
62682a34 | 323 | &ast::ItemFn(ref decl, _, _, _, ref generics, _) => { |
1a4d82fc | 324 | let no_output = match decl.output { |
85aaf69f SL |
325 | ast::DefaultReturn(..) => true, |
326 | ast::Return(ref t) if t.node == ast::TyTup(vec![]) => true, | |
327 | _ => false | |
1a4d82fc JJ |
328 | }; |
329 | if decl.inputs.is_empty() | |
330 | && no_output | |
331 | && !generics.is_parameterized() { | |
332 | Yes | |
333 | } else { | |
334 | No | |
335 | } | |
336 | } | |
337 | _ => NotEvenAFunction, | |
338 | } | |
339 | } | |
340 | ||
341 | if has_test_attr { | |
342 | let diag = cx.span_diagnostic; | |
343 | match has_test_signature(i) { | |
344 | Yes => {}, | |
345 | No => diag.span_err(i.span, "functions used as tests must have signature fn() -> ()"), | |
346 | NotEvenAFunction => diag.span_err(i.span, | |
347 | "only functions may be used as tests"), | |
348 | } | |
349 | } | |
350 | ||
351 | return has_test_attr && has_test_signature(i) == Yes; | |
352 | } | |
353 | ||
354 | fn is_bench_fn(cx: &TestCtxt, i: &ast::Item) -> bool { | |
c34b1796 | 355 | let has_bench_attr = attr::contains_name(&i.attrs, "bench"); |
1a4d82fc JJ |
356 | |
357 | fn has_test_signature(i: &ast::Item) -> bool { | |
358 | match i.node { | |
62682a34 | 359 | ast::ItemFn(ref decl, _, _, _, ref generics, _) => { |
1a4d82fc JJ |
360 | let input_cnt = decl.inputs.len(); |
361 | let no_output = match decl.output { | |
85aaf69f SL |
362 | ast::DefaultReturn(..) => true, |
363 | ast::Return(ref t) if t.node == ast::TyTup(vec![]) => true, | |
364 | _ => false | |
1a4d82fc JJ |
365 | }; |
366 | let tparm_cnt = generics.ty_params.len(); | |
367 | // NB: inadequate check, but we're running | |
368 | // well before resolve, can't get too deep. | |
85aaf69f SL |
369 | input_cnt == 1 |
370 | && no_output && tparm_cnt == 0 | |
1a4d82fc JJ |
371 | } |
372 | _ => false | |
373 | } | |
374 | } | |
375 | ||
376 | if has_bench_attr && !has_test_signature(i) { | |
377 | let diag = cx.span_diagnostic; | |
378 | diag.span_err(i.span, "functions used as benches must have signature \ | |
379 | `fn(&mut Bencher) -> ()`"); | |
380 | } | |
381 | ||
382 | return has_bench_attr && has_test_signature(i); | |
383 | } | |
384 | ||
385 | fn is_ignored(i: &ast::Item) -> bool { | |
386 | i.attrs.iter().any(|attr| attr.check_name("ignore")) | |
387 | } | |
388 | ||
c34b1796 AL |
389 | fn should_panic(i: &ast::Item) -> ShouldPanic { |
390 | match i.attrs.iter().find(|attr| attr.check_name("should_panic")) { | |
1a4d82fc JJ |
391 | Some(attr) => { |
392 | let msg = attr.meta_item_list() | |
393 | .and_then(|list| list.iter().find(|mi| mi.check_name("expected"))) | |
394 | .and_then(|mi| mi.value_str()); | |
c34b1796 | 395 | ShouldPanic::Yes(msg) |
1a4d82fc | 396 | } |
c34b1796 | 397 | None => ShouldPanic::No, |
1a4d82fc JJ |
398 | } |
399 | } | |
400 | ||
401 | /* | |
402 | ||
403 | We're going to be building a module that looks more or less like: | |
404 | ||
405 | mod __test { | |
406 | extern crate test (name = "test", vers = "..."); | |
407 | fn main() { | |
408 | test::test_main_static(&::os::args()[], tests) | |
409 | } | |
410 | ||
411 | static tests : &'static [test::TestDescAndFn] = &[ | |
412 | ... the list of tests in the crate ... | |
413 | ]; | |
414 | } | |
415 | ||
416 | */ | |
417 | ||
85aaf69f | 418 | fn mk_std(cx: &TestCtxt) -> P<ast::Item> { |
1a4d82fc | 419 | let id_test = token::str_to_ident("test"); |
85aaf69f SL |
420 | let (vi, vis, ident) = if cx.is_test_crate { |
421 | (ast::ItemUse( | |
1a4d82fc | 422 | P(nospan(ast::ViewPathSimple(id_test, |
85aaf69f SL |
423 | path_node(vec!(id_test)))))), |
424 | ast::Public, token::special_idents::invalid) | |
1a4d82fc | 425 | } else { |
85aaf69f | 426 | (ast::ItemExternCrate(None), ast::Inherited, id_test) |
1a4d82fc | 427 | }; |
85aaf69f SL |
428 | P(ast::Item { |
429 | id: ast::DUMMY_NODE_ID, | |
430 | ident: ident, | |
1a4d82fc | 431 | node: vi, |
85aaf69f | 432 | attrs: vec![], |
1a4d82fc JJ |
433 | vis: vis, |
434 | span: DUMMY_SP | |
85aaf69f | 435 | }) |
1a4d82fc JJ |
436 | } |
437 | ||
85aaf69f SL |
438 | fn mk_main(cx: &mut TestCtxt) -> P<ast::Item> { |
439 | // Writing this out by hand with 'ignored_span': | |
440 | // pub fn main() { | |
441 | // #![main] | |
442 | // use std::slice::AsSlice; | |
443 | // test::test_main_static(::std::os::args().as_slice(), TESTS); | |
444 | // } | |
445 | ||
446 | let sp = ignored_span(cx, DUMMY_SP); | |
447 | let ecx = &cx.ext_cx; | |
448 | ||
449 | // test::test_main_static | |
450 | let test_main_path = ecx.path(sp, vec![token::str_to_ident("test"), | |
451 | token::str_to_ident("test_main_static")]); | |
452 | // ::std::env::args | |
453 | let os_args_path = ecx.path_global(sp, vec![token::str_to_ident("std"), | |
454 | token::str_to_ident("env"), | |
455 | token::str_to_ident("args")]); | |
456 | // ::std::env::args() | |
457 | let os_args_path_expr = ecx.expr_path(os_args_path); | |
458 | let call_os_args = ecx.expr_call(sp, os_args_path_expr, vec![]); | |
459 | // test::test_main_static(...) | |
460 | let test_main_path_expr = ecx.expr_path(test_main_path); | |
461 | let tests_ident_expr = ecx.expr_ident(sp, token::str_to_ident("TESTS")); | |
462 | let call_test_main = ecx.expr_call(sp, test_main_path_expr, | |
463 | vec![call_os_args, tests_ident_expr]); | |
464 | let call_test_main = ecx.stmt_expr(call_test_main); | |
465 | // #![main] | |
466 | let main_meta = ecx.meta_word(sp, token::intern_and_get_ident("main")); | |
467 | let main_attr = ecx.attribute(sp, main_meta); | |
468 | // pub fn main() { ... } | |
469 | let main_ret_ty = ecx.ty(sp, ast::TyTup(vec![])); | |
470 | let main_body = ecx.block_all(sp, vec![call_test_main], None); | |
471 | let main = ast::ItemFn(ecx.fn_decl(vec![], main_ret_ty), | |
62682a34 SL |
472 | ast::Unsafety::Normal, |
473 | ast::Constness::NotConst, | |
474 | ::abi::Rust, empty_generics(), main_body); | |
85aaf69f SL |
475 | let main = P(ast::Item { |
476 | ident: token::str_to_ident("main"), | |
477 | attrs: vec![main_attr], | |
478 | id: ast::DUMMY_NODE_ID, | |
479 | node: main, | |
480 | vis: ast::Public, | |
481 | span: sp | |
482 | }); | |
483 | ||
484 | return main; | |
485 | } | |
486 | ||
487 | fn mk_test_module(cx: &mut TestCtxt) -> (P<ast::Item>, Option<P<ast::Item>>) { | |
1a4d82fc | 488 | // Link to test crate |
85aaf69f | 489 | let import = mk_std(cx); |
1a4d82fc JJ |
490 | |
491 | // A constant vector of test descriptors. | |
492 | let tests = mk_tests(cx); | |
493 | ||
494 | // The synthesized main function which will call the console test runner | |
495 | // with our list of tests | |
85aaf69f | 496 | let mainfn = mk_main(cx); |
1a4d82fc JJ |
497 | |
498 | let testmod = ast::Mod { | |
499 | inner: DUMMY_SP, | |
85aaf69f | 500 | items: vec![import, mainfn, tests], |
1a4d82fc JJ |
501 | }; |
502 | let item_ = ast::ItemMod(testmod); | |
503 | ||
504 | let mod_ident = token::gensym_ident("__test"); | |
85aaf69f | 505 | let item = P(ast::Item { |
1a4d82fc | 506 | id: ast::DUMMY_NODE_ID, |
85aaf69f SL |
507 | ident: mod_ident, |
508 | attrs: vec![], | |
1a4d82fc JJ |
509 | node: item_, |
510 | vis: ast::Public, | |
511 | span: DUMMY_SP, | |
85aaf69f | 512 | }); |
1a4d82fc JJ |
513 | let reexport = cx.reexport_test_harness_main.as_ref().map(|s| { |
514 | // building `use <ident> = __test::main` | |
85aaf69f | 515 | let reexport_ident = token::str_to_ident(&s); |
1a4d82fc JJ |
516 | |
517 | let use_path = | |
518 | nospan(ast::ViewPathSimple(reexport_ident, | |
85aaf69f | 519 | path_node(vec![mod_ident, token::str_to_ident("main")]))); |
1a4d82fc | 520 | |
85aaf69f SL |
521 | P(ast::Item { |
522 | id: ast::DUMMY_NODE_ID, | |
523 | ident: token::special_idents::invalid, | |
1a4d82fc | 524 | attrs: vec![], |
85aaf69f | 525 | node: ast::ItemUse(P(use_path)), |
1a4d82fc JJ |
526 | vis: ast::Inherited, |
527 | span: DUMMY_SP | |
85aaf69f | 528 | }) |
1a4d82fc JJ |
529 | }); |
530 | ||
85aaf69f | 531 | debug!("Synthetic test module:\n{}\n", pprust::item_to_string(&*item)); |
1a4d82fc | 532 | |
85aaf69f | 533 | (item, reexport) |
1a4d82fc JJ |
534 | } |
535 | ||
536 | fn nospan<T>(t: T) -> codemap::Spanned<T> { | |
537 | codemap::Spanned { node: t, span: DUMMY_SP } | |
538 | } | |
539 | ||
540 | fn path_node(ids: Vec<ast::Ident> ) -> ast::Path { | |
541 | ast::Path { | |
542 | span: DUMMY_SP, | |
543 | global: false, | |
544 | segments: ids.into_iter().map(|identifier| ast::PathSegment { | |
545 | identifier: identifier, | |
546 | parameters: ast::PathParameters::none(), | |
547 | }).collect() | |
548 | } | |
549 | } | |
550 | ||
551 | fn mk_tests(cx: &TestCtxt) -> P<ast::Item> { | |
552 | // The vector of test_descs for this crate | |
553 | let test_descs = mk_test_descs(cx); | |
554 | ||
555 | // FIXME #15962: should be using quote_item, but that stringifies | |
556 | // __test_reexports, causing it to be reinterned, losing the | |
557 | // gensym information. | |
558 | let sp = DUMMY_SP; | |
559 | let ecx = &cx.ext_cx; | |
560 | let struct_type = ecx.ty_path(ecx.path(sp, vec![ecx.ident_of("self"), | |
561 | ecx.ident_of("test"), | |
562 | ecx.ident_of("TestDescAndFn")])); | |
563 | let static_lt = ecx.lifetime(sp, token::special_idents::static_lifetime.name); | |
564 | // &'static [self::test::TestDescAndFn] | |
565 | let static_type = ecx.ty_rptr(sp, | |
566 | ecx.ty(sp, ast::TyVec(struct_type)), | |
567 | Some(static_lt), | |
568 | ast::MutImmutable); | |
569 | // static TESTS: $static_type = &[...]; | |
570 | ecx.item_const(sp, | |
571 | ecx.ident_of("TESTS"), | |
572 | static_type, | |
573 | test_descs) | |
574 | } | |
575 | ||
576 | fn is_test_crate(krate: &ast::Crate) -> bool { | |
c34b1796 | 577 | match attr::find_crate_name(&krate.attrs) { |
85aaf69f | 578 | Some(ref s) if "test" == &s[..] => true, |
1a4d82fc JJ |
579 | _ => false |
580 | } | |
581 | } | |
582 | ||
583 | fn mk_test_descs(cx: &TestCtxt) -> P<ast::Expr> { | |
584 | debug!("building test vector from {} tests", cx.testfns.len()); | |
585 | ||
586 | P(ast::Expr { | |
587 | id: ast::DUMMY_NODE_ID, | |
588 | node: ast::ExprAddrOf(ast::MutImmutable, | |
589 | P(ast::Expr { | |
590 | id: ast::DUMMY_NODE_ID, | |
591 | node: ast::ExprVec(cx.testfns.iter().map(|test| { | |
592 | mk_test_desc_and_fn_rec(cx, test) | |
593 | }).collect()), | |
594 | span: DUMMY_SP, | |
595 | })), | |
596 | span: DUMMY_SP, | |
597 | }) | |
598 | } | |
599 | ||
600 | fn mk_test_desc_and_fn_rec(cx: &TestCtxt, test: &Test) -> P<ast::Expr> { | |
601 | // FIXME #15962: should be using quote_expr, but that stringifies | |
602 | // __test_reexports, causing it to be reinterned, losing the | |
603 | // gensym information. | |
604 | ||
85aaf69f | 605 | let span = ignored_span(cx, test.span); |
1a4d82fc JJ |
606 | let path = test.path.clone(); |
607 | let ecx = &cx.ext_cx; | |
608 | let self_id = ecx.ident_of("self"); | |
609 | let test_id = ecx.ident_of("test"); | |
610 | ||
611 | // creates self::test::$name | |
85aaf69f | 612 | let test_path = |name| { |
1a4d82fc JJ |
613 | ecx.path(span, vec![self_id, test_id, ecx.ident_of(name)]) |
614 | }; | |
615 | // creates $name: $expr | |
85aaf69f | 616 | let field = |name, expr| ecx.field_imm(span, ecx.ident_of(name), expr); |
1a4d82fc | 617 | |
85aaf69f | 618 | debug!("encoding {}", ast_util::path_name_i(&path[..])); |
1a4d82fc JJ |
619 | |
620 | // path to the #[test] function: "foo::bar::baz" | |
85aaf69f SL |
621 | let path_string = ast_util::path_name_i(&path[..]); |
622 | let name_expr = ecx.expr_str(span, token::intern_and_get_ident(&path_string[..])); | |
1a4d82fc JJ |
623 | |
624 | // self::test::StaticTestName($name_expr) | |
625 | let name_expr = ecx.expr_call(span, | |
626 | ecx.expr_path(test_path("StaticTestName")), | |
627 | vec![name_expr]); | |
628 | ||
629 | let ignore_expr = ecx.expr_bool(span, test.ignore); | |
c34b1796 AL |
630 | let should_panic_path = |name| { |
631 | ecx.path(span, vec![self_id, test_id, ecx.ident_of("ShouldPanic"), ecx.ident_of(name)]) | |
1a4d82fc | 632 | }; |
c34b1796 AL |
633 | let fail_expr = match test.should_panic { |
634 | ShouldPanic::No => ecx.expr_path(should_panic_path("No")), | |
635 | ShouldPanic::Yes(ref msg) => { | |
636 | let path = should_panic_path("Yes"); | |
1a4d82fc JJ |
637 | let arg = match *msg { |
638 | Some(ref msg) => ecx.expr_some(span, ecx.expr_str(span, msg.clone())), | |
639 | None => ecx.expr_none(span), | |
640 | }; | |
641 | ecx.expr_call(span, ecx.expr_path(path), vec![arg]) | |
642 | } | |
643 | }; | |
644 | ||
645 | // self::test::TestDesc { ... } | |
646 | let desc_expr = ecx.expr_struct( | |
647 | span, | |
648 | test_path("TestDesc"), | |
649 | vec![field("name", name_expr), | |
650 | field("ignore", ignore_expr), | |
c34b1796 | 651 | field("should_panic", fail_expr)]); |
1a4d82fc JJ |
652 | |
653 | ||
654 | let mut visible_path = match cx.toplevel_reexport { | |
655 | Some(id) => vec![id], | |
656 | None => { | |
657 | let diag = cx.span_diagnostic; | |
658 | diag.handler.bug("expected to find top-level re-export name, but found None"); | |
659 | } | |
660 | }; | |
62682a34 | 661 | visible_path.extend(path); |
1a4d82fc JJ |
662 | |
663 | let fn_expr = ecx.expr_path(ecx.path_global(span, visible_path)); | |
664 | ||
665 | let variant_name = if test.bench { "StaticBenchFn" } else { "StaticTestFn" }; | |
666 | // self::test::$variant_name($fn_expr) | |
667 | let testfn_expr = ecx.expr_call(span, ecx.expr_path(test_path(variant_name)), vec![fn_expr]); | |
668 | ||
669 | // self::test::TestDescAndFn { ... } | |
670 | ecx.expr_struct(span, | |
671 | test_path("TestDescAndFn"), | |
672 | vec![field("desc", desc_expr), | |
673 | field("testfn", testfn_expr)]) | |
674 | } |