src/libsyntax/test.rs

   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
  16 use self::HasTestSignature::*;
  17
  18 use std::iter;
  19 use std::slice;
  20 use std::mem;
  21 use std::vec;
  22 use attr::{self, HasAttrs};
  23 use syntax_pos::{self, DUMMY_SP, NO_EXPANSION, Span, FileMap, BytePos};
  24 use std::rc::Rc;
  25
  26 use codemap::{self, CodeMap, ExpnInfo, NameAndSpan, MacroAttribute, dummy_spanned};
  27 use errors;
  28 use config;
  29 use entry::{self, EntryPointType};
  30 use ext::base::{ExtCtxt, Resolver};
  31 use ext::build::AstBuilder;
  32 use ext::expand::ExpansionConfig;
  33 use ext::hygiene::{Mark, SyntaxContext};
  34 use fold::Folder;
  35 use util::move_map::MoveMap;
  36 use fold;
  37 use parse::{token, ParseSess};
  38 use print::pprust;
  39 use ast::{self, Ident};
  40 use ptr::P;
  41 use symbol::{self, Symbol, keywords};
  42 use util::small_vector::SmallVector;
  43
  44 enum ShouldPanic {
  45     No,
  46     Yes(Option<Symbol>),
  47 }
  48
  49 struct Test {
  50     span: Span,
  51     path: Vec<Ident> ,
  52     bench: bool,
  53     ignore: bool,
  54     should_panic: ShouldPanic,
  55     allow_fail: bool,
  56 }
  57
  58 struct TestCtxt<'a> {
  59     sess: &'a ParseSess,
  60     span_diagnostic: &'a errors::Handler,
  61     path: Vec<Ident>,
  62     ext_cx: ExtCtxt<'a>,
  63     testfns: Vec<Test>,
  64     reexport_test_harness_main: Option<Symbol>,
  65     is_test_crate: bool,
  66     ctxt: SyntaxContext,
  67
  68     // top-level re-export submodule, filled out after folding is finished
  69     toplevel_reexport: Option<Ident>,
  70 }
  71
  72 // Traverse the crate, collecting all the test functions, eliding any
  73 // existing main functions, and synthesizing a main test harness
  74 pub fn modify_for_testing(sess: &ParseSess,
  75                           resolver: &mut Resolver,
  76                           should_test: bool,
  77                           krate: ast::Crate,
  78                           span_diagnostic: &errors::Handler) -> ast::Crate {
  79     // Check for #[reexport_test_harness_main = "some_name"] which
  80     // creates a `use some_name = __test::main;`. This needs to be
  81     // unconditional, so that the attribute is still marked as used in
  82     // non-test builds.
  83     let reexport_test_harness_main =
  84         attr::first_attr_value_str_by_name(&krate.attrs,
  85                                            "reexport_test_harness_main");
  86
  87     if should_test {
  88         generate_test_harness(sess, resolver, reexport_test_harness_main, krate, span_diagnostic)
  89     } else {
  90         krate
  91     }
  92 }
  93
  94 struct TestHarnessGenerator<'a> {
  95     cx: TestCtxt<'a>,
  96     tests: Vec<Ident>,
  97
  98     // submodule name, gensym'd identifier for re-exports
  99     tested_submods: Vec<(Ident, Ident)>,
 100 }
 101
 102 impl<'a> fold::Folder for TestHarnessGenerator<'a> {
 103     fn fold_crate(&mut self, c: ast::Crate) -> ast::Crate {
 104         let mut folded = fold::noop_fold_crate(c, self);
 105
 106         // Add a special __test module to the crate that will contain code
 107         // generated for the test harness
 108         let (mod_, reexport) = mk_test_module(&mut self.cx);
 109         if let Some(re) = reexport {
 110             folded.module.items.push(re)
 111         }
 112         folded.module.items.push(mod_);
 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 != keywords::Invalid.name() {
 119             self.cx.path.push(ident);
 120         }
 121         debug!("current path: {}", path_name_i(&self.cx.path));
 122
 123         if is_test_fn(&self.cx, &i) || is_bench_fn(&self.cx, &i) {
 124             match i.node {
 125                 ast::ItemKind::Fn(_, ast::Unsafety::Unsafe, _, _, _, _) => {
 126                     let diag = self.cx.span_diagnostic;
 127                     panic!(diag.span_fatal(i.span, "unsafe functions cannot be used for tests"));
 128                 }
 129                 _ => {
 130                     debug!("this is a test function");
 131                     let test = Test {
 132                         span: i.span,
 133                         path: self.cx.path.clone(),
 134                         bench: is_bench_fn(&self.cx, &i),
 135                         ignore: is_ignored(&i),
 136                         should_panic: should_panic(&i, &self.cx),
 137                         allow_fail: is_allowed_fail(&i),
 138                     };
 139                     self.cx.testfns.push(test);
 140                     self.tests.push(i.ident);
 141                 }
 142             }
 143         }
 144
 145         let mut item = i.unwrap();
 146         // We don't want to recurse into anything other than mods, since
 147         // mods or tests inside of functions will break things
 148         if let ast::ItemKind::Mod(module) = item.node {
 149             let tests = mem::replace(&mut self.tests, Vec::new());
 150             let tested_submods = mem::replace(&mut self.tested_submods, Vec::new());
 151             let mut mod_folded = fold::noop_fold_mod(module, self);
 152             let tests = mem::replace(&mut self.tests, tests);
 153             let tested_submods = mem::replace(&mut self.tested_submods, tested_submods);
 154
 155             if !tests.is_empty() || !tested_submods.is_empty() {
 156                 let (it, sym) = mk_reexport_mod(&mut self.cx, item.id, tests, tested_submods);
 157                 mod_folded.items.push(it);
 158
 159                 if !self.cx.path.is_empty() {
 160                     self.tested_submods.push((self.cx.path[self.cx.path.len()-1], sym));
 161                 } else {
 162                     debug!("pushing nothing, sym: {:?}", sym);
 163                     self.cx.toplevel_reexport = Some(sym);
 164                 }
 165             }
 166             item.node = ast::ItemKind::Mod(mod_folded);
 167         }
 168         if ident.name != keywords::Invalid.name() {
 169             self.cx.path.pop();
 170         }
 171         SmallVector::one(P(item))
 172     }
 173
 174     fn fold_mac(&mut self, mac: ast::Mac) -> ast::Mac { mac }
 175 }
 176
 177 struct EntryPointCleaner {
 178     // Current depth in the ast
 179     depth: usize,
 180 }
 181
 182 impl fold::Folder for EntryPointCleaner {
 183     fn fold_item(&mut self, i: P<ast::Item>) -> SmallVector<P<ast::Item>> {
 184         self.depth += 1;
 185         let folded = fold::noop_fold_item(i, self).expect_one("noop did something");
 186         self.depth -= 1;
 187
 188         // Remove any #[main] or #[start] from the AST so it doesn't
 189         // clash with the one we're going to add, but mark it as
 190         // #[allow(dead_code)] to avoid printing warnings.
 191         let folded = match entry::entry_point_type(&folded, self.depth) {
 192             EntryPointType::MainNamed |
 193             EntryPointType::MainAttr |
 194             EntryPointType::Start =>
 195                 folded.map(|ast::Item {id, ident, attrs, node, vis, span, tokens}| {
 196                     let allow_str = Symbol::intern("allow");
 197                     let dead_code_str = Symbol::intern("dead_code");
 198                     let word_vec = vec![attr::mk_list_word_item(dead_code_str)];
 199                     let allow_dead_code_item = attr::mk_list_item(allow_str, word_vec);
 200                     let allow_dead_code = attr::mk_attr_outer(DUMMY_SP,
 201                                                               attr::mk_attr_id(),
 202                                                               allow_dead_code_item);
 203
 204                     ast::Item {
 205                         id: id,
 206                         ident: ident,
 207                         attrs: attrs.into_iter()
 208                             .filter(|attr| {
 209                                 !attr.check_name("main") && !attr.check_name("start")
 210                             })
 211                             .chain(iter::once(allow_dead_code))
 212                             .collect(),
 213                         node: node,
 214                         vis: vis,
 215                         span: span,
 216                         tokens: tokens,
 217                     }
 218                 }),
 219             EntryPointType::None |
 220             EntryPointType::OtherMain => folded,
 221         };
 222
 223         SmallVector::one(folded)
 224     }
 225
 226     fn fold_mac(&mut self, mac: ast::Mac) -> ast::Mac { mac }
 227 }
 228
 229 fn mk_reexport_mod(cx: &mut TestCtxt,
 230                    parent: ast::NodeId,
 231                    tests: Vec<Ident>,
 232                    tested_submods: Vec<(Ident, Ident)>)
 233                    -> (P<ast::Item>, Ident) {
 234     let super_ = Ident::from_str("super");
 235
 236     let items = tests.into_iter().map(|r| {
 237         cx.ext_cx.item_use_simple(DUMMY_SP, ast::Visibility::Public,
 238                                   cx.ext_cx.path(DUMMY_SP, vec![super_, r]))
 239     }).chain(tested_submods.into_iter().map(|(r, sym)| {
 240         let path = cx.ext_cx.path(DUMMY_SP, vec![super_, r, sym]);
 241         cx.ext_cx.item_use_simple_(DUMMY_SP, ast::Visibility::Public, r, path)
 242     })).collect();
 243
 244     let reexport_mod = ast::Mod {
 245         inner: DUMMY_SP,
 246         items: items,
 247     };
 248
 249     let sym = Ident::with_empty_ctxt(Symbol::gensym("__test_reexports"));
 250     let parent = if parent == ast::DUMMY_NODE_ID { ast::CRATE_NODE_ID } else { parent };
 251     cx.ext_cx.current_expansion.mark = cx.ext_cx.resolver.get_module_scope(parent);
 252     let it = cx.ext_cx.monotonic_expander().fold_item(P(ast::Item {
 253         ident: sym,
 254         attrs: Vec::new(),
 255         id: ast::DUMMY_NODE_ID,
 256         node: ast::ItemKind::Mod(reexport_mod),
 257         vis: ast::Visibility::Public,
 258         span: DUMMY_SP,
 259         tokens: None,
 260     })).pop().unwrap();
 261
 262     (it, sym)
 263 }
 264
 265 fn generate_test_harness(sess: &ParseSess,
 266                          resolver: &mut Resolver,
 267                          reexport_test_harness_main: Option<Symbol>,
 268                          krate: ast::Crate,
 269                          sd: &errors::Handler) -> ast::Crate {
 270     // Remove the entry points
 271     let mut cleaner = EntryPointCleaner { depth: 0 };
 272     let krate = cleaner.fold_crate(krate);
 273
 274     let mark = Mark::fresh(Mark::root());
 275     let mut cx: TestCtxt = TestCtxt {
 276         sess: sess,
 277         span_diagnostic: sd,
 278         ext_cx: ExtCtxt::new(sess, ExpansionConfig::default("test".to_string()), resolver),
 279         path: Vec::new(),
 280         testfns: Vec::new(),
 281         reexport_test_harness_main: reexport_test_harness_main,
 282         is_test_crate: is_test_crate(&krate),
 283         toplevel_reexport: None,
 284         ctxt: SyntaxContext::empty().apply_mark(mark),
 285     };
 286     cx.ext_cx.crate_root = Some("std");
 287
 288     mark.set_expn_info(ExpnInfo {
 289         call_site: DUMMY_SP,
 290         callee: NameAndSpan {
 291             format: MacroAttribute(Symbol::intern("test")),
 292             span: None,
 293             allow_internal_unstable: true,
 294         }
 295     });
 296
 297     TestHarnessGenerator {
 298         cx: cx,
 299         tests: Vec::new(),
 300         tested_submods: Vec::new(),
 301     }.fold_crate(krate)
 302 }
 303
 304 /// Craft a span that will be ignored by the stability lint's
 305 /// call to codemap's `is_internal` check.
 306 /// The expanded code calls some unstable functions in the test crate.
 307 fn ignored_span(cx: &TestCtxt, sp: Span) -> Span {
 308     Span { ctxt: cx.ctxt, ..sp }
 309 }
 310
 311 #[derive(PartialEq)]
 312 enum HasTestSignature {
 313     Yes,
 314     No,
 315     NotEvenAFunction,
 316 }
 317
 318 fn is_test_fn(cx: &TestCtxt, i: &ast::Item) -> bool {
 319     let has_test_attr = attr::contains_name(&i.attrs, "test");
 320
 321     fn has_test_signature(i: &ast::Item) -> HasTestSignature {
 322         match i.node {
 323           ast::ItemKind::Fn(ref decl, _, _, _, ref generics, _) => {
 324             let no_output = match decl.output {
 325                 ast::FunctionRetTy::Default(..) => true,
 326                 ast::FunctionRetTy::Ty(ref t) if t.node == ast::TyKind::Tup(vec![]) => true,
 327                 _ => false
 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     has_test_attr && has_test_signature(i) == Yes
 352 }
 353
 354 fn is_bench_fn(cx: &TestCtxt, i: &ast::Item) -> bool {
 355     let has_bench_attr = attr::contains_name(&i.attrs, "bench");
 356
 357     fn has_test_signature(i: &ast::Item) -> bool {
 358         match i.node {
 359             ast::ItemKind::Fn(ref decl, _, _, _, ref generics, _) => {
 360                 let input_cnt = decl.inputs.len();
 361                 let no_output = match decl.output {
 362                     ast::FunctionRetTy::Default(..) => true,
 363                     ast::FunctionRetTy::Ty(ref t) if t.node == ast::TyKind::Tup(vec![]) => true,
 364                     _ => false
 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.
 369                 input_cnt == 1
 370                     && no_output && tparm_cnt == 0
 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     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
 389 fn is_allowed_fail(i: &ast::Item) -> bool {
 390     i.attrs.iter().any(|attr| attr.check_name("allow_fail"))
 391 }
 392
 393 fn should_panic(i: &ast::Item, cx: &TestCtxt) -> ShouldPanic {
 394     match i.attrs.iter().find(|attr| attr.check_name("should_panic")) {
 395         Some(attr) => {
 396             let sd = cx.span_diagnostic;
 397             if attr.is_value_str() {
 398                 sd.struct_span_warn(
 399                     attr.span(),
 400                     "attribute must be of the form: \
 401                      `#[should_panic]` or \
 402                      `#[should_panic(expected = \"error message\")]`"
 403                 ).note("Errors in this attribute were erroneously allowed \
 404                         and will become a hard error in a future release.")
 405                 .emit();
 406                 return ShouldPanic::Yes(None);
 407             }
 408             match attr.meta_item_list() {
 409                 // Handle #[should_panic]
 410                 None => ShouldPanic::Yes(None),
 411                 // Handle #[should_panic(expected = "foo")]
 412                 Some(list) => {
 413                     let msg = list.iter()
 414                         .find(|mi| mi.check_name("expected"))
 415                         .and_then(|mi| mi.meta_item())
 416                         .and_then(|mi| mi.value_str());
 417                     if list.len() != 1 || msg.is_none() {
 418                         sd.struct_span_warn(
 419                             attr.span(),
 420                             "argument must be of the form: \
 421                              `expected = \"error message\"`"
 422                         ).note("Errors in this attribute were erroneously \
 423                                 allowed and will become a hard error in a \
 424                                 future release.").emit();
 425                         ShouldPanic::Yes(None)
 426                     } else {
 427                         ShouldPanic::Yes(msg)
 428                     }
 429                 },
 430             }
 431         }
 432         None => ShouldPanic::No,
 433     }
 434 }
 435
 436 /*
 437
 438 We're going to be building a module that looks more or less like:
 439
 440 mod __test {
 441   extern crate test (name = "test", vers = "...");
 442   fn main() {
 443     test::test_main_static(&::os::args()[], tests, test::Options::new())
 444   }
 445
 446   static tests : &'static [test::TestDescAndFn] = &[
 447     ... the list of tests in the crate ...
 448   ];
 449 }
 450
 451 */
 452
 453 fn mk_std(cx: &TestCtxt) -> P<ast::Item> {
 454     let id_test = Ident::from_str("test");
 455     let sp = ignored_span(cx, DUMMY_SP);
 456     let (vi, vis, ident) = if cx.is_test_crate {
 457         (ast::ItemKind::Use(
 458             P(nospan(ast::ViewPathSimple(id_test,
 459                                          path_node(vec![id_test]))))),
 460          ast::Visibility::Public, keywords::Invalid.ident())
 461     } else {
 462         (ast::ItemKind::ExternCrate(None), ast::Visibility::Inherited, id_test)
 463     };
 464     P(ast::Item {
 465         id: ast::DUMMY_NODE_ID,
 466         ident: ident,
 467         node: vi,
 468         attrs: vec![],
 469         vis: vis,
 470         span: sp,
 471         tokens: None,
 472     })
 473 }
 474
 475 fn mk_main(cx: &mut TestCtxt) -> P<ast::Item> {
 476     // Writing this out by hand with 'ignored_span':
 477     //        pub fn main() {
 478     //            #![main]
 479     //            use std::slice::AsSlice;
 480     //            test::test_main_static(::std::os::args().as_slice(), TESTS, test::Options::new());
 481     //        }
 482
 483     let sp = ignored_span(cx, DUMMY_SP);
 484     let ecx = &cx.ext_cx;
 485
 486     // test::test_main_static
 487     let test_main_path =
 488         ecx.path(sp, vec![Ident::from_str("test"), Ident::from_str("test_main_static")]);
 489
 490     // test::test_main_static(...)
 491     let test_main_path_expr = ecx.expr_path(test_main_path);
 492     let tests_ident_expr = ecx.expr_ident(sp, Ident::from_str("TESTS"));
 493     let call_test_main = ecx.expr_call(sp, test_main_path_expr,
 494                                        vec![tests_ident_expr]);
 495     let call_test_main = ecx.stmt_expr(call_test_main);
 496     // #![main]
 497     let main_meta = ecx.meta_word(sp, Symbol::intern("main"));
 498     let main_attr = ecx.attribute(sp, main_meta);
 499     // pub fn main() { ... }
 500     let main_ret_ty = ecx.ty(sp, ast::TyKind::Tup(vec![]));
 501     let main_body = ecx.block(sp, vec![call_test_main]);
 502     let main = ast::ItemKind::Fn(ecx.fn_decl(vec![], main_ret_ty),
 503                            ast::Unsafety::Normal,
 504                            dummy_spanned(ast::Constness::NotConst),
 505                            ::abi::Abi::Rust, ast::Generics::default(), main_body);
 506     P(ast::Item {
 507         ident: Ident::from_str("main"),
 508         attrs: vec![main_attr],
 509         id: ast::DUMMY_NODE_ID,
 510         node: main,
 511         vis: ast::Visibility::Public,
 512         span: sp,
 513         tokens: None,
 514     })
 515 }
 516
 517 fn mk_test_module(cx: &mut TestCtxt) -> (P<ast::Item>, Option<P<ast::Item>>) {
 518     // Link to test crate
 519     let import = mk_std(cx);
 520
 521     // A constant vector of test descriptors.
 522     let tests = mk_tests(cx);
 523
 524     // The synthesized main function which will call the console test runner
 525     // with our list of tests
 526     let mainfn = mk_main(cx);
 527
 528     let testmod = ast::Mod {
 529         inner: DUMMY_SP,
 530         items: vec![import, mainfn, tests],
 531     };
 532     let item_ = ast::ItemKind::Mod(testmod);
 533     let mod_ident = Ident::with_empty_ctxt(Symbol::gensym("__test"));
 534
 535     let mut expander = cx.ext_cx.monotonic_expander();
 536     let item = expander.fold_item(P(ast::Item {
 537         id: ast::DUMMY_NODE_ID,
 538         ident: mod_ident,
 539         attrs: vec![],
 540         node: item_,
 541         vis: ast::Visibility::Public,
 542         span: DUMMY_SP,
 543         tokens: None,
 544     })).pop().unwrap();
 545     let reexport = cx.reexport_test_harness_main.map(|s| {
 546         // building `use <ident> = __test::main`
 547         let reexport_ident = Ident::with_empty_ctxt(s);
 548
 549         let use_path =
 550             nospan(ast::ViewPathSimple(reexport_ident,
 551                                        path_node(vec![mod_ident, Ident::from_str("main")])));
 552
 553         expander.fold_item(P(ast::Item {
 554             id: ast::DUMMY_NODE_ID,
 555             ident: keywords::Invalid.ident(),
 556             attrs: vec![],
 557             node: ast::ItemKind::Use(P(use_path)),
 558             vis: ast::Visibility::Inherited,
 559             span: DUMMY_SP,
 560             tokens: None,
 561         })).pop().unwrap()
 562     });
 563
 564     debug!("Synthetic test module:\n{}\n", pprust::item_to_string(&item));
 565
 566     (item, reexport)
 567 }
 568
 569 fn nospan<T>(t: T) -> codemap::Spanned<T> {
 570     codemap::Spanned { node: t, span: DUMMY_SP }
 571 }
 572
 573 fn path_node(ids: Vec<Ident>) -> ast::Path {
 574     ast::Path {
 575         span: DUMMY_SP,
 576         segments: ids.into_iter().map(|id| ast::PathSegment::from_ident(id, DUMMY_SP)).collect(),
 577     }
 578 }
 579
 580 fn path_name_i(idents: &[Ident]) -> String {
 581     // FIXME: Bad copies (#2543 -- same for everything else that says "bad")
 582     idents.iter().map(|i| i.to_string()).collect::<Vec<String>>().join("::")
 583 }
 584
 585 fn mk_tests(cx: &TestCtxt) -> P<ast::Item> {
 586     // The vector of test_descs for this crate
 587     let test_descs = mk_test_descs(cx);
 588
 589     // FIXME #15962: should be using quote_item, but that stringifies
 590     // __test_reexports, causing it to be reinterned, losing the
 591     // gensym information.
 592     let sp = ignored_span(cx, DUMMY_SP);
 593     let ecx = &cx.ext_cx;
 594     let struct_type = ecx.ty_path(ecx.path(sp, vec![ecx.ident_of("self"),
 595                                                     ecx.ident_of("test"),
 596                                                     ecx.ident_of("TestDescAndFn")]));
 597     let static_lt = ecx.lifetime(sp, keywords::StaticLifetime.ident());
 598     // &'static [self::test::TestDescAndFn]
 599     let static_type = ecx.ty_rptr(sp,
 600                                   ecx.ty(sp, ast::TyKind::Slice(struct_type)),
 601                                   Some(static_lt),
 602                                   ast::Mutability::Immutable);
 603     // static TESTS: $static_type = &[...];
 604     ecx.item_const(sp,
 605                    ecx.ident_of("TESTS"),
 606                    static_type,
 607                    test_descs)
 608 }
 609
 610 fn is_test_crate(krate: &ast::Crate) -> bool {
 611     match attr::find_crate_name(&krate.attrs) {
 612         Some(s) if "test" == s.as_str() => true,
 613         _ => false
 614     }
 615 }
 616
 617 fn mk_test_descs(cx: &TestCtxt) -> P<ast::Expr> {
 618     debug!("building test vector from {} tests", cx.testfns.len());
 619
 620     P(ast::Expr {
 621         id: ast::DUMMY_NODE_ID,
 622         node: ast::ExprKind::AddrOf(ast::Mutability::Immutable,
 623             P(ast::Expr {
 624                 id: ast::DUMMY_NODE_ID,
 625                 node: ast::ExprKind::Array(cx.testfns.iter().map(|test| {
 626                     mk_test_desc_and_fn_rec(cx, test)
 627                 }).collect()),
 628                 span: DUMMY_SP,
 629                 attrs: ast::ThinVec::new(),
 630             })),
 631         span: DUMMY_SP,
 632         attrs: ast::ThinVec::new(),
 633     })
 634 }
 635
 636 fn mk_test_desc_and_fn_rec(cx: &TestCtxt, test: &Test) -> P<ast::Expr> {
 637     // FIXME #15962: should be using quote_expr, but that stringifies
 638     // __test_reexports, causing it to be reinterned, losing the
 639     // gensym information.
 640
 641     let span = ignored_span(cx, test.span);
 642     let path = test.path.clone();
 643     let ecx = &cx.ext_cx;
 644     let self_id = ecx.ident_of("self");
 645     let test_id = ecx.ident_of("test");
 646
 647     // creates self::test::$name
 648     let test_path = |name| {
 649         ecx.path(span, vec![self_id, test_id, ecx.ident_of(name)])
 650     };
 651     // creates $name: $expr
 652     let field = |name, expr| ecx.field_imm(span, ecx.ident_of(name), expr);
 653
 654     debug!("encoding {}", path_name_i(&path[..]));
 655
 656     // path to the #[test] function: "foo::bar::baz"
 657     let path_string = path_name_i(&path[..]);
 658     let name_expr = ecx.expr_str(span, Symbol::intern(&path_string));
 659
 660     // self::test::StaticTestName($name_expr)
 661     let name_expr = ecx.expr_call(span,
 662                                   ecx.expr_path(test_path("StaticTestName")),
 663                                   vec![name_expr]);
 664
 665     let ignore_expr = ecx.expr_bool(span, test.ignore);
 666     let should_panic_path = |name| {
 667         ecx.path(span, vec![self_id, test_id, ecx.ident_of("ShouldPanic"), ecx.ident_of(name)])
 668     };
 669     let fail_expr = match test.should_panic {
 670         ShouldPanic::No => ecx.expr_path(should_panic_path("No")),
 671         ShouldPanic::Yes(msg) => {
 672             match msg {
 673                 Some(msg) => {
 674                     let msg = ecx.expr_str(span, msg);
 675                     let path = should_panic_path("YesWithMessage");
 676                     ecx.expr_call(span, ecx.expr_path(path), vec![msg])
 677                 }
 678                 None => ecx.expr_path(should_panic_path("Yes")),
 679             }
 680         }
 681     };
 682     let allow_fail_expr = ecx.expr_bool(span, test.allow_fail);
 683
 684     // self::test::TestDesc { ... }
 685     let desc_expr = ecx.expr_struct(
 686         span,
 687         test_path("TestDesc"),
 688         vec![field("name", name_expr),
 689              field("ignore", ignore_expr),
 690              field("should_panic", fail_expr),
 691              field("allow_fail", allow_fail_expr)]);
 692
 693
 694     let mut visible_path = match cx.toplevel_reexport {
 695         Some(id) => vec![id],
 696         None => {
 697             let diag = cx.span_diagnostic;
 698             diag.bug("expected to find top-level re-export name, but found None");
 699         }
 700     };
 701     visible_path.extend(path);
 702
 703     let fn_expr = ecx.expr_path(ecx.path_global(span, visible_path));
 704
 705     let variant_name = if test.bench { "StaticBenchFn" } else { "StaticTestFn" };
 706     // self::test::$variant_name($fn_expr)
 707     let testfn_expr = ecx.expr_call(span, ecx.expr_path(test_path(variant_name)), vec![fn_expr]);
 708
 709     // self::test::TestDescAndFn { ... }
 710     ecx.expr_struct(span,
 711                     test_path("TestDescAndFn"),
 712                     vec![field("desc", desc_expr),
 713                          field("testfn", testfn_expr)])
 714 }