src/libsyntax/test.rs

   1 // Code that generates a test runner to run all the tests in a crate
   2
   3 #![allow(dead_code)]
   4 #![allow(unused_imports)]
   5
   6 use self::HasTestSignature::*;
   7
   8 use std::iter;
   9 use std::slice;
  10 use std::mem;
  11 use std::vec;
  12 use attr::{self, HasAttrs};
  13 use syntax_pos::{self, DUMMY_SP, NO_EXPANSION, Span, SourceFile, BytePos};
  14
  15 use source_map::{self, SourceMap, ExpnInfo, MacroAttribute, dummy_spanned, respan};
  16 use errors;
  17 use config;
  18 use entry::{self, EntryPointType};
  19 use ext::base::{ExtCtxt, Resolver};
  20 use ext::build::AstBuilder;
  21 use ext::expand::ExpansionConfig;
  22 use ext::hygiene::{self, Mark, SyntaxContext};
  23 use mut_visit::{*, ExpectOne};
  24 use feature_gate::Features;
  25 use util::map_in_place::MapInPlace;
  26 use parse::{token, ParseSess};
  27 use print::pprust;
  28 use ast::{self, Ident};
  29 use ptr::P;
  30 use smallvec::SmallVec;
  31 use symbol::{self, Symbol, keywords};
  32 use ThinVec;
  33
  34 struct Test {
  35     span: Span,
  36     path: Vec<Ident>,
  37 }
  38
  39 struct TestCtxt<'a> {
  40     span_diagnostic: &'a errors::Handler,
  41     path: Vec<Ident>,
  42     ext_cx: ExtCtxt<'a>,
  43     test_cases: Vec<Test>,
  44     reexport_test_harness_main: Option<Symbol>,
  45     is_libtest: bool,
  46     ctxt: SyntaxContext,
  47     features: &'a Features,
  48     test_runner: Option<ast::Path>,
  49
  50     // top-level re-export submodule, filled out after folding is finished
  51     toplevel_reexport: Option<Ident>,
  52 }
  53
  54 // Traverse the crate, collecting all the test functions, eliding any
  55 // existing main functions, and synthesizing a main test harness
  56 pub fn modify_for_testing(sess: &ParseSess,
  57                           resolver: &mut dyn Resolver,
  58                           should_test: bool,
  59                           krate: &mut ast::Crate,
  60                           span_diagnostic: &errors::Handler,
  61                           features: &Features) {
  62     // Check for #[reexport_test_harness_main = "some_name"] which
  63     // creates a `use __test::main as some_name;`. This needs to be
  64     // unconditional, so that the attribute is still marked as used in
  65     // non-test builds.
  66     let reexport_test_harness_main =
  67         attr::first_attr_value_str_by_name(&krate.attrs,
  68                                            "reexport_test_harness_main");
  69
  70     // Do this here so that the test_runner crate attribute gets marked as used
  71     // even in non-test builds
  72     let test_runner = get_test_runner(span_diagnostic, &krate);
  73
  74     if should_test {
  75         generate_test_harness(sess, resolver, reexport_test_harness_main,
  76                               krate, span_diagnostic, features, test_runner)
  77     }
  78 }
  79
  80 struct TestHarnessGenerator<'a> {
  81     cx: TestCtxt<'a>,
  82     tests: Vec<Ident>,
  83
  84     // submodule name, gensym'd identifier for re-exports
  85     tested_submods: Vec<(Ident, Ident)>,
  86 }
  87
  88 impl<'a> MutVisitor for TestHarnessGenerator<'a> {
  89     fn visit_crate(&mut self, c: &mut ast::Crate) {
  90         noop_visit_crate(c, self);
  91
  92         // Create a main function to run our tests
  93         let test_main = {
  94             let unresolved = mk_main(&mut self.cx);
  95             self.cx.ext_cx.monotonic_expander().flat_map_item(unresolved).pop().unwrap()
  96         };
  97
  98         c.module.items.push(test_main);
  99     }
 100
 101     fn flat_map_item(&mut self, i: P<ast::Item>) -> SmallVec<[P<ast::Item>; 1]> {
 102         let ident = i.ident;
 103         if ident.name != keywords::Invalid.name() {
 104             self.cx.path.push(ident);
 105         }
 106         debug!("current path: {}", path_name_i(&self.cx.path));
 107
 108         let mut item = i.into_inner();
 109         if is_test_case(&item) {
 110             debug!("this is a test item");
 111
 112             let test = Test {
 113                 span: item.span,
 114                 path: self.cx.path.clone(),
 115             };
 116             self.cx.test_cases.push(test);
 117             self.tests.push(item.ident);
 118         }
 119
 120         // We don't want to recurse into anything other than mods, since
 121         // mods or tests inside of functions will break things
 122         if let ast::ItemKind::Mod(mut module) = item.node {
 123             let tests = mem::replace(&mut self.tests, Vec::new());
 124             let tested_submods = mem::replace(&mut self.tested_submods, Vec::new());
 125             noop_visit_mod(&mut module, self);
 126             let tests = mem::replace(&mut self.tests, tests);
 127             let tested_submods = mem::replace(&mut self.tested_submods, tested_submods);
 128
 129             if !tests.is_empty() || !tested_submods.is_empty() {
 130                 let (it, sym) = mk_reexport_mod(&mut self.cx, item.id, tests, tested_submods);
 131                 module.items.push(it);
 132
 133                 if !self.cx.path.is_empty() {
 134                     self.tested_submods.push((self.cx.path[self.cx.path.len()-1], sym));
 135                 } else {
 136                     debug!("pushing nothing, sym: {:?}", sym);
 137                     self.cx.toplevel_reexport = Some(sym);
 138                 }
 139             }
 140             item.node = ast::ItemKind::Mod(module);
 141         }
 142         if ident.name != keywords::Invalid.name() {
 143             self.cx.path.pop();
 144         }
 145         smallvec![P(item)]
 146     }
 147
 148     fn visit_mac(&mut self, _mac: &mut ast::Mac) {
 149         // Do nothing.
 150     }
 151 }
 152
 153 /// A folder used to remove any entry points (like fn main) because the harness
 154 /// generator will provide its own
 155 struct EntryPointCleaner {
 156     // Current depth in the ast
 157     depth: usize,
 158 }
 159
 160 impl MutVisitor for EntryPointCleaner {
 161     fn flat_map_item(&mut self, i: P<ast::Item>) -> SmallVec<[P<ast::Item>; 1]> {
 162         self.depth += 1;
 163         let item = noop_flat_map_item(i, self).expect_one("noop did something");
 164         self.depth -= 1;
 165
 166         // Remove any #[main] or #[start] from the AST so it doesn't
 167         // clash with the one we're going to add, but mark it as
 168         // #[allow(dead_code)] to avoid printing warnings.
 169         let item = match entry::entry_point_type(&item, self.depth) {
 170             EntryPointType::MainNamed |
 171             EntryPointType::MainAttr |
 172             EntryPointType::Start =>
 173                 item.map(|ast::Item {id, ident, attrs, node, vis, span, tokens}| {
 174                     let allow_ident = Ident::from_str("allow");
 175                     let dc_nested = attr::mk_nested_word_item(Ident::from_str("dead_code"));
 176                     let allow_dead_code_item = attr::mk_list_item(DUMMY_SP, allow_ident,
 177                                                                   vec![dc_nested]);
 178                     let allow_dead_code = attr::mk_attr_outer(DUMMY_SP,
 179                                                               attr::mk_attr_id(),
 180                                                               allow_dead_code_item);
 181
 182                     ast::Item {
 183                         id,
 184                         ident,
 185                         attrs: attrs.into_iter()
 186                             .filter(|attr| {
 187                                 !attr.check_name("main") && !attr.check_name("start")
 188                             })
 189                             .chain(iter::once(allow_dead_code))
 190                             .collect(),
 191                         node,
 192                         vis,
 193                         span,
 194                         tokens,
 195                     }
 196                 }),
 197             EntryPointType::None |
 198             EntryPointType::OtherMain => item,
 199         };
 200
 201         smallvec![item]
 202     }
 203
 204     fn visit_mac(&mut self, _mac: &mut ast::Mac) {
 205         // Do nothing.
 206     }
 207 }
 208
 209 /// Creates an item (specifically a module) that "pub use"s the tests passed in.
 210 /// Each tested submodule will contain a similar reexport module that we will export
 211 /// under the name of the original module. That is, `submod::__test_reexports` is
 212 /// reexported like so `pub use submod::__test_reexports as submod`.
 213 fn mk_reexport_mod(cx: &mut TestCtxt,
 214                    parent: ast::NodeId,
 215                    tests: Vec<Ident>,
 216                    tested_submods: Vec<(Ident, Ident)>)
 217                    -> (P<ast::Item>, Ident) {
 218     let super_ = Ident::from_str("super");
 219
 220     let items = tests.into_iter().map(|r| {
 221         cx.ext_cx.item_use_simple(DUMMY_SP, dummy_spanned(ast::VisibilityKind::Public),
 222                                   cx.ext_cx.path(DUMMY_SP, vec![super_, r]))
 223     }).chain(tested_submods.into_iter().map(|(r, sym)| {
 224         let path = cx.ext_cx.path(DUMMY_SP, vec![super_, r, sym]);
 225         cx.ext_cx.item_use_simple_(DUMMY_SP, dummy_spanned(ast::VisibilityKind::Public),
 226                                    Some(r), path)
 227     })).collect();
 228
 229     let reexport_mod = ast::Mod {
 230         inline: true,
 231         inner: DUMMY_SP,
 232         items,
 233     };
 234
 235     let sym = Ident::with_empty_ctxt(Symbol::gensym("__test_reexports"));
 236     let parent = if parent == ast::DUMMY_NODE_ID { ast::CRATE_NODE_ID } else { parent };
 237     cx.ext_cx.current_expansion.mark = cx.ext_cx.resolver.get_module_scope(parent);
 238     let it = cx.ext_cx.monotonic_expander().flat_map_item(P(ast::Item {
 239         ident: sym,
 240         attrs: Vec::new(),
 241         id: ast::DUMMY_NODE_ID,
 242         node: ast::ItemKind::Mod(reexport_mod),
 243         vis: dummy_spanned(ast::VisibilityKind::Public),
 244         span: DUMMY_SP,
 245         tokens: None,
 246     })).pop().unwrap();
 247
 248     (it, sym)
 249 }
 250
 251 /// Crawl over the crate, inserting test reexports and the test main function
 252 fn generate_test_harness(sess: &ParseSess,
 253                          resolver: &mut dyn Resolver,
 254                          reexport_test_harness_main: Option<Symbol>,
 255                          krate: &mut ast::Crate,
 256                          sd: &errors::Handler,
 257                          features: &Features,
 258                          test_runner: Option<ast::Path>) {
 259     // Remove the entry points
 260     let mut cleaner = EntryPointCleaner { depth: 0 };
 261     cleaner.visit_crate(krate);
 262
 263     let mark = Mark::fresh(Mark::root());
 264
 265     let mut econfig = ExpansionConfig::default("test".to_string());
 266     econfig.features = Some(features);
 267
 268     let cx = TestCtxt {
 269         span_diagnostic: sd,
 270         ext_cx: ExtCtxt::new(sess, econfig, resolver),
 271         path: Vec::new(),
 272         test_cases: Vec::new(),
 273         reexport_test_harness_main,
 274         // N.B., doesn't consider the value of `--crate-name` passed on the command line.
 275         is_libtest: attr::find_crate_name(&krate.attrs).map(|s| s == "test").unwrap_or(false),
 276         toplevel_reexport: None,
 277         ctxt: SyntaxContext::empty().apply_mark(mark),
 278         features,
 279         test_runner
 280     };
 281
 282     mark.set_expn_info(ExpnInfo {
 283         call_site: DUMMY_SP,
 284         def_site: None,
 285         format: MacroAttribute(Symbol::intern("test_case")),
 286         allow_internal_unstable: true,
 287         allow_internal_unsafe: false,
 288         local_inner_macros: false,
 289         edition: hygiene::default_edition(),
 290     });
 291
 292     TestHarnessGenerator {
 293         cx,
 294         tests: Vec::new(),
 295         tested_submods: Vec::new(),
 296     }.visit_crate(krate);
 297 }
 298
 299 /// Craft a span that will be ignored by the stability lint's
 300 /// call to source_map's `is_internal` check.
 301 /// The expanded code calls some unstable functions in the test crate.
 302 fn ignored_span(cx: &TestCtxt, sp: Span) -> Span {
 303     sp.with_ctxt(cx.ctxt)
 304 }
 305
 306 enum HasTestSignature {
 307     Yes,
 308     No(BadTestSignature),
 309 }
 310
 311 #[derive(PartialEq)]
 312 enum BadTestSignature {
 313     NotEvenAFunction,
 314     WrongTypeSignature,
 315     NoArgumentsAllowed,
 316     ShouldPanicOnlyWithNoArgs,
 317 }
 318
 319 /// Creates a function item for use as the main function of a test build.
 320 /// This function will call the `test_runner` as specified by the crate attribute
 321 fn mk_main(cx: &mut TestCtxt) -> P<ast::Item> {
 322     // Writing this out by hand with 'ignored_span':
 323     //        pub fn main() {
 324     //            #![main]
 325     //            test::test_main_static(::std::os::args().as_slice(), &[..tests]);
 326     //        }
 327     let sp = ignored_span(cx, DUMMY_SP);
 328     let ecx = &cx.ext_cx;
 329     let test_id = ecx.ident_of("test").gensym();
 330
 331     // test::test_main_static(...)
 332     let mut test_runner = cx.test_runner.clone().unwrap_or(
 333         ecx.path(sp, vec![
 334             test_id, ecx.ident_of("test_main_static")
 335         ]));
 336
 337     test_runner.span = sp;
 338
 339     let test_main_path_expr = ecx.expr_path(test_runner);
 340     let call_test_main = ecx.expr_call(sp, test_main_path_expr,
 341                                        vec![mk_tests_slice(cx)]);
 342     let call_test_main = ecx.stmt_expr(call_test_main);
 343
 344     // #![main]
 345     let main_meta = ecx.meta_word(sp, Symbol::intern("main"));
 346     let main_attr = ecx.attribute(sp, main_meta);
 347
 348     // extern crate test as test_gensym
 349     let test_extern_stmt = ecx.stmt_item(sp, ecx.item(sp,
 350         test_id,
 351         vec![],
 352         ast::ItemKind::ExternCrate(Some(Symbol::intern("test")))
 353     ));
 354
 355     // pub fn main() { ... }
 356     let main_ret_ty = ecx.ty(sp, ast::TyKind::Tup(vec![]));
 357
 358     // If no test runner is provided we need to import the test crate
 359     let main_body = if cx.test_runner.is_none() {
 360         ecx.block(sp, vec![test_extern_stmt, call_test_main])
 361     } else {
 362         ecx.block(sp, vec![call_test_main])
 363     };
 364
 365     let main = ast::ItemKind::Fn(ecx.fn_decl(vec![], ast::FunctionRetTy::Ty(main_ret_ty)),
 366                            ast::FnHeader::default(),
 367                            ast::Generics::default(),
 368                            main_body);
 369
 370     // Honor the reexport_test_harness_main attribute
 371     let main_id = Ident::new(
 372         cx.reexport_test_harness_main.unwrap_or(Symbol::gensym("main")),
 373         sp);
 374
 375     P(ast::Item {
 376         ident: main_id,
 377         attrs: vec![main_attr],
 378         id: ast::DUMMY_NODE_ID,
 379         node: main,
 380         vis: dummy_spanned(ast::VisibilityKind::Public),
 381         span: sp,
 382         tokens: None,
 383     })
 384
 385 }
 386
 387 fn path_name_i(idents: &[Ident]) -> String {
 388     let mut path_name = "".to_string();
 389     let mut idents_iter = idents.iter().peekable();
 390     while let Some(ident) = idents_iter.next() {
 391         path_name.push_str(&ident.as_str());
 392         if idents_iter.peek().is_some() {
 393             path_name.push_str("::")
 394         }
 395     }
 396     path_name
 397 }
 398
 399 /// Creates a slice containing every test like so:
 400 /// &[path::to::test1, path::to::test2]
 401 fn mk_tests_slice(cx: &TestCtxt) -> P<ast::Expr> {
 402     debug!("building test vector from {} tests", cx.test_cases.len());
 403     let ref ecx = cx.ext_cx;
 404
 405     ecx.expr_vec_slice(DUMMY_SP,
 406         cx.test_cases.iter().map(|test| {
 407             ecx.expr_addr_of(test.span,
 408                 ecx.expr_path(ecx.path(test.span, visible_path(cx, &test.path))))
 409         }).collect())
 410 }
 411
 412 /// Creates a path from the top-level __test module to the test via __test_reexports
 413 fn visible_path(cx: &TestCtxt, path: &[Ident]) -> Vec<Ident>{
 414     let mut visible_path = vec![];
 415     match cx.toplevel_reexport {
 416         Some(id) => visible_path.push(id),
 417         None => {
 418             cx.span_diagnostic.bug("expected to find top-level re-export name, but found None");
 419         }
 420     }
 421     visible_path.extend_from_slice(path);
 422     visible_path
 423 }
 424
 425 fn is_test_case(i: &ast::Item) -> bool {
 426     attr::contains_name(&i.attrs, "rustc_test_marker")
 427 }
 428
 429 fn get_test_runner(sd: &errors::Handler, krate: &ast::Crate) -> Option<ast::Path> {
 430     let test_attr = attr::find_by_name(&krate.attrs, "test_runner")?;
 431     test_attr.meta_item_list().map(|meta_list| {
 432         if meta_list.len() != 1 {
 433             sd.span_fatal(test_attr.span(),
 434                 "#![test_runner(..)] accepts exactly 1 argument").raise()
 435         }
 436         meta_list[0].word().as_ref().unwrap().ident.clone()
 437     })
 438 }