compiler/rustc_builtin_macros/src/test_harness.rs

   1 // Code that generates a test runner to run all the tests in a crate
   2
   3 use rustc_ast as ast;
   4 use rustc_ast::attr;
   5 use rustc_ast::entry::EntryPointType;
   6 use rustc_ast::mut_visit::{ExpectOne, *};
   7 use rustc_ast::ptr::P;
   8 use rustc_expand::base::{ExtCtxt, ResolverExpand};
   9 use rustc_expand::expand::{AstFragment, ExpansionConfig};
  10 use rustc_feature::Features;
  11 use rustc_session::Session;
  12 use rustc_span::hygiene::{AstPass, SyntaxContext, Transparency};
  13 use rustc_span::symbol::{sym, Ident, Symbol};
  14 use rustc_span::{Span, DUMMY_SP};
  15 use rustc_target::spec::PanicStrategy;
  16 use smallvec::{smallvec, SmallVec};
  17 use tracing::debug;
  18
  19 use std::{iter, mem};
  20
  21 struct Test {
  22     span: Span,
  23     ident: Ident,
  24 }
  25
  26 struct TestCtxt<'a> {
  27     ext_cx: ExtCtxt<'a>,
  28     panic_strategy: PanicStrategy,
  29     def_site: Span,
  30     test_cases: Vec<Test>,
  31     reexport_test_harness_main: Option<Symbol>,
  32     test_runner: Option<ast::Path>,
  33 }
  34
  35 // Traverse the crate, collecting all the test functions, eliding any
  36 // existing main functions, and synthesizing a main test harness
  37 pub fn inject(sess: &Session, resolver: &mut dyn ResolverExpand, krate: &mut ast::Crate) {
  38     let span_diagnostic = sess.diagnostic();
  39     let panic_strategy = sess.panic_strategy();
  40     let platform_panic_strategy = sess.target.options.panic_strategy;
  41
  42     // Check for #![reexport_test_harness_main = "some_name"] which gives the
  43     // main test function the name `some_name` without hygiene. This needs to be
  44     // unconditional, so that the attribute is still marked as used in
  45     // non-test builds.
  46     let reexport_test_harness_main =
  47         sess.first_attr_value_str_by_name(&krate.attrs, sym::reexport_test_harness_main);
  48
  49     // Do this here so that the test_runner crate attribute gets marked as used
  50     // even in non-test builds
  51     let test_runner = get_test_runner(sess, span_diagnostic, &krate);
  52
  53     if sess.opts.test {
  54         let panic_strategy = match (panic_strategy, sess.opts.debugging_opts.panic_abort_tests) {
  55             (PanicStrategy::Abort, true) => PanicStrategy::Abort,
  56             (PanicStrategy::Abort, false) => {
  57                 if panic_strategy == platform_panic_strategy {
  58                     // Silently allow compiling with panic=abort on these platforms,
  59                     // but with old behavior (abort if a test fails).
  60                 } else {
  61                     span_diagnostic.err(
  62                         "building tests with panic=abort is not supported \
  63                                          without `-Zpanic_abort_tests`",
  64                     );
  65                 }
  66                 PanicStrategy::Unwind
  67             }
  68             (PanicStrategy::Unwind, _) => PanicStrategy::Unwind,
  69         };
  70         generate_test_harness(
  71             sess,
  72             resolver,
  73             reexport_test_harness_main,
  74             krate,
  75             &sess.features_untracked(),
  76             panic_strategy,
  77             test_runner,
  78         )
  79     }
  80 }
  81
  82 struct TestHarnessGenerator<'a> {
  83     cx: TestCtxt<'a>,
  84     tests: Vec<Test>,
  85 }
  86
  87 impl<'a> MutVisitor for TestHarnessGenerator<'a> {
  88     fn visit_crate(&mut self, c: &mut ast::Crate) {
  89         noop_visit_crate(c, self);
  90
  91         // Create a main function to run our tests
  92         c.module.items.push(mk_main(&mut self.cx));
  93     }
  94
  95     fn flat_map_item(&mut self, i: P<ast::Item>) -> SmallVec<[P<ast::Item>; 1]> {
  96         let mut item = i.into_inner();
  97         if is_test_case(&self.cx.ext_cx.sess, &item) {
  98             debug!("this is a test item");
  99
 100             let test = Test { span: item.span, ident: item.ident };
 101             self.tests.push(test);
 102         }
 103
 104         // We don't want to recurse into anything other than mods, since
 105         // mods or tests inside of functions will break things
 106         if let ast::ItemKind::Mod(mut module) = item.kind {
 107             let tests = mem::take(&mut self.tests);
 108             noop_visit_mod(&mut module, self);
 109             let mut tests = mem::replace(&mut self.tests, tests);
 110
 111             if !tests.is_empty() {
 112                 let parent =
 113                     if item.id == ast::DUMMY_NODE_ID { ast::CRATE_NODE_ID } else { item.id };
 114                 // Create an identifier that will hygienically resolve the test
 115                 // case name, even in another module.
 116                 let expn_id = self.cx.ext_cx.resolver.expansion_for_ast_pass(
 117                     module.inner,
 118                     AstPass::TestHarness,
 119                     &[],
 120                     Some(parent),
 121                 );
 122                 for test in &mut tests {
 123                     // See the comment on `mk_main` for why we're using
 124                     // `apply_mark` directly.
 125                     test.ident.span = test.ident.span.apply_mark(expn_id, Transparency::Opaque);
 126                 }
 127                 self.cx.test_cases.extend(tests);
 128             }
 129             item.kind = ast::ItemKind::Mod(module);
 130         }
 131         smallvec![P(item)]
 132     }
 133
 134     fn visit_mac(&mut self, _mac: &mut ast::MacCall) {
 135         // Do nothing.
 136     }
 137 }
 138
 139 // Beware, this is duplicated in librustc_passes/entry.rs (with
 140 // `rustc_hir::Item`), so make sure to keep them in sync.
 141 fn entry_point_type(sess: &Session, item: &ast::Item, depth: usize) -> EntryPointType {
 142     match item.kind {
 143         ast::ItemKind::Fn(..) => {
 144             if sess.contains_name(&item.attrs, sym::start) {
 145                 EntryPointType::Start
 146             } else if sess.contains_name(&item.attrs, sym::main) {
 147                 EntryPointType::MainAttr
 148             } else if item.ident.name == sym::main {
 149                 if depth == 1 {
 150                     // This is a top-level function so can be 'main'
 151                     EntryPointType::MainNamed
 152                 } else {
 153                     EntryPointType::OtherMain
 154                 }
 155             } else {
 156                 EntryPointType::None
 157             }
 158         }
 159         _ => EntryPointType::None,
 160     }
 161 }
 162 /// A folder used to remove any entry points (like fn main) because the harness
 163 /// generator will provide its own
 164 struct EntryPointCleaner<'a> {
 165     // Current depth in the ast
 166     sess: &'a Session,
 167     depth: usize,
 168     def_site: Span,
 169 }
 170
 171 impl<'a> MutVisitor for EntryPointCleaner<'a> {
 172     fn flat_map_item(&mut self, i: P<ast::Item>) -> SmallVec<[P<ast::Item>; 1]> {
 173         self.depth += 1;
 174         let item = noop_flat_map_item(i, self).expect_one("noop did something");
 175         self.depth -= 1;
 176
 177         // Remove any #[main] or #[start] from the AST so it doesn't
 178         // clash with the one we're going to add, but mark it as
 179         // #[allow(dead_code)] to avoid printing warnings.
 180         let item = match entry_point_type(self.sess, &item, self.depth) {
 181             EntryPointType::MainNamed | EntryPointType::MainAttr | EntryPointType::Start => item
 182                 .map(|ast::Item { id, ident, attrs, kind, vis, span, tokens }| {
 183                     let allow_ident = Ident::new(sym::allow, self.def_site);
 184                     let dc_nested =
 185                         attr::mk_nested_word_item(Ident::new(sym::dead_code, self.def_site));
 186                     let allow_dead_code_item = attr::mk_list_item(allow_ident, vec![dc_nested]);
 187                     let allow_dead_code = attr::mk_attr_outer(allow_dead_code_item);
 188                     let attrs = attrs
 189                         .into_iter()
 190                         .filter(|attr| {
 191                             !self.sess.check_name(attr, sym::main)
 192                                 && !self.sess.check_name(attr, sym::start)
 193                         })
 194                         .chain(iter::once(allow_dead_code))
 195                         .collect();
 196
 197                     ast::Item { id, ident, attrs, kind, vis, span, tokens }
 198                 }),
 199             EntryPointType::None | EntryPointType::OtherMain => item,
 200         };
 201
 202         smallvec![item]
 203     }
 204
 205     fn visit_mac(&mut self, _mac: &mut ast::MacCall) {
 206         // Do nothing.
 207     }
 208 }
 209
 210 /// Crawl over the crate, inserting test reexports and the test main function
 211 fn generate_test_harness(
 212     sess: &Session,
 213     resolver: &mut dyn ResolverExpand,
 214     reexport_test_harness_main: Option<Symbol>,
 215     krate: &mut ast::Crate,
 216     features: &Features,
 217     panic_strategy: PanicStrategy,
 218     test_runner: Option<ast::Path>,
 219 ) {
 220     let mut econfig = ExpansionConfig::default("test".to_string());
 221     econfig.features = Some(features);
 222
 223     let ext_cx = ExtCtxt::new(sess, econfig, resolver, None);
 224
 225     let expn_id = ext_cx.resolver.expansion_for_ast_pass(
 226         DUMMY_SP,
 227         AstPass::TestHarness,
 228         &[sym::main, sym::test, sym::rustc_attrs],
 229         None,
 230     );
 231     let def_site = DUMMY_SP.with_def_site_ctxt(expn_id);
 232
 233     // Remove the entry points
 234     let mut cleaner = EntryPointCleaner { sess, depth: 0, def_site };
 235     cleaner.visit_crate(krate);
 236
 237     let cx = TestCtxt {
 238         ext_cx,
 239         panic_strategy,
 240         def_site,
 241         test_cases: Vec::new(),
 242         reexport_test_harness_main,
 243         test_runner,
 244     };
 245
 246     TestHarnessGenerator { cx, tests: Vec::new() }.visit_crate(krate);
 247 }
 248
 249 /// Creates a function item for use as the main function of a test build.
 250 /// This function will call the `test_runner` as specified by the crate attribute
 251 ///
 252 /// By default this expands to
 253 ///
 254 /// ```
 255 /// #[main]
 256 /// pub fn main() {
 257 ///     extern crate test;
 258 ///     test::test_main_static(&[
 259 ///         &test_const1,
 260 ///         &test_const2,
 261 ///         &test_const3,
 262 ///     ]);
 263 /// }
 264 /// ```
 265 ///
 266 /// Most of the Ident have the usual def-site hygiene for the AST pass. The
 267 /// exception is the `test_const`s. These have a syntax context that has two
 268 /// opaque marks: one from the expansion of `test` or `test_case`, and one
 269 /// generated  in `TestHarnessGenerator::flat_map_item`. When resolving this
 270 /// identifier after failing to find a matching identifier in the root module
 271 /// we remove the outer mark, and try resolving at its def-site, which will
 272 /// then resolve to `test_const`.
 273 ///
 274 /// The expansion here can be controlled by two attributes:
 275 ///
 276 /// [`TestCtxt::reexport_test_harness_main`] provides a different name for the `main`
 277 /// function and [`TestCtxt::test_runner`] provides a path that replaces
 278 /// `test::test_main_static`.
 279 fn mk_main(cx: &mut TestCtxt<'_>) -> P<ast::Item> {
 280     let sp = cx.def_site;
 281     let ecx = &cx.ext_cx;
 282     let test_id = Ident::new(sym::test, sp);
 283
 284     let runner_name = match cx.panic_strategy {
 285         PanicStrategy::Unwind => "test_main_static",
 286         PanicStrategy::Abort => "test_main_static_abort",
 287     };
 288
 289     // test::test_main_static(...)
 290     let mut test_runner = cx
 291         .test_runner
 292         .clone()
 293         .unwrap_or(ecx.path(sp, vec![test_id, Ident::from_str_and_span(runner_name, sp)]));
 294
 295     test_runner.span = sp;
 296
 297     let test_main_path_expr = ecx.expr_path(test_runner);
 298     let call_test_main = ecx.expr_call(sp, test_main_path_expr, vec![mk_tests_slice(cx, sp)]);
 299     let call_test_main = ecx.stmt_expr(call_test_main);
 300
 301     // extern crate test
 302     let test_extern_stmt =
 303         ecx.stmt_item(sp, ecx.item(sp, test_id, vec![], ast::ItemKind::ExternCrate(None)));
 304
 305     // #[main]
 306     let main_meta = ecx.meta_word(sp, sym::main);
 307     let main_attr = ecx.attribute(main_meta);
 308
 309     // pub fn main() { ... }
 310     let main_ret_ty = ecx.ty(sp, ast::TyKind::Tup(vec![]));
 311
 312     // If no test runner is provided we need to import the test crate
 313     let main_body = if cx.test_runner.is_none() {
 314         ecx.block(sp, vec![test_extern_stmt, call_test_main])
 315     } else {
 316         ecx.block(sp, vec![call_test_main])
 317     };
 318
 319     let decl = ecx.fn_decl(vec![], ast::FnRetTy::Ty(main_ret_ty));
 320     let sig = ast::FnSig { decl, header: ast::FnHeader::default(), span: sp };
 321     let def = ast::Defaultness::Final;
 322     let main = ast::ItemKind::Fn(def, sig, ast::Generics::default(), Some(main_body));
 323
 324     // Honor the reexport_test_harness_main attribute
 325     let main_id = match cx.reexport_test_harness_main {
 326         Some(sym) => Ident::new(sym, sp.with_ctxt(SyntaxContext::root())),
 327         None => Ident::new(sym::main, sp),
 328     };
 329
 330     let main = P(ast::Item {
 331         ident: main_id,
 332         attrs: vec![main_attr],
 333         id: ast::DUMMY_NODE_ID,
 334         kind: main,
 335         vis: ast::Visibility { span: sp, kind: ast::VisibilityKind::Public, tokens: None },
 336         span: sp,
 337         tokens: None,
 338     });
 339
 340     // Integrate the new item into existing module structures.
 341     let main = AstFragment::Items(smallvec![main]);
 342     cx.ext_cx.monotonic_expander().fully_expand_fragment(main).make_items().pop().unwrap()
 343 }
 344
 345 /// Creates a slice containing every test like so:
 346 /// &[&test1, &test2]
 347 fn mk_tests_slice(cx: &TestCtxt<'_>, sp: Span) -> P<ast::Expr> {
 348     debug!("building test vector from {} tests", cx.test_cases.len());
 349     let ecx = &cx.ext_cx;
 350
 351     ecx.expr_vec_slice(
 352         sp,
 353         cx.test_cases
 354             .iter()
 355             .map(|test| {
 356                 ecx.expr_addr_of(test.span, ecx.expr_path(ecx.path(test.span, vec![test.ident])))
 357             })
 358             .collect(),
 359     )
 360 }
 361
 362 fn is_test_case(sess: &Session, i: &ast::Item) -> bool {
 363     sess.contains_name(&i.attrs, sym::rustc_test_marker)
 364 }
 365
 366 fn get_test_runner(
 367     sess: &Session,
 368     sd: &rustc_errors::Handler,
 369     krate: &ast::Crate,
 370 ) -> Option<ast::Path> {
 371     let test_attr = sess.find_by_name(&krate.attrs, sym::test_runner)?;
 372     let meta_list = test_attr.meta_item_list()?;
 373     let span = test_attr.span;
 374     match &*meta_list {
 375         [single] => match single.meta_item() {
 376             Some(meta_item) if meta_item.is_word() => return Some(meta_item.path.clone()),
 377             _ => sd.struct_span_err(span, "`test_runner` argument must be a path").emit(),
 378         },
 379         _ => sd.struct_span_err(span, "`#![test_runner(..)]` accepts exactly 1 argument").emit(),
 380     }
 381     None
 382 }