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