1 // Code that generates a test runner to run all the tests in a crate
6 use rustc_ast::entry::{self, EntryPointType};
7 use rustc_ast::mut_visit::{ExpectOne, *};
9 use rustc_expand::base::{ExtCtxt, ResolverExpand};
10 use rustc_expand::expand::{AstFragment, ExpansionConfig};
11 use rustc_feature::Features;
12 use rustc_session::parse::ParseSess;
13 use rustc_span::hygiene::{AstPass, SyntaxContext, Transparency};
14 use rustc_span::source_map::respan;
15 use rustc_span::symbol::{sym, Ident, Symbol};
16 use rustc_span::{Span, DUMMY_SP};
17 use rustc_target::spec::PanicStrategy;
18 use smallvec::{smallvec, SmallVec};
29 panic_strategy: PanicStrategy,
31 test_cases: Vec<Test>,
32 reexport_test_harness_main: Option<Symbol>,
33 test_runner: Option<ast::Path>,
36 // Traverse the crate, collecting all the test functions, eliding any
37 // existing main functions, and synthesizing a main test harness
40 resolver: &mut dyn ResolverExpand,
42 krate: &mut ast::Crate,
43 span_diagnostic: &rustc_errors::Handler,
45 panic_strategy: PanicStrategy,
46 platform_panic_strategy: PanicStrategy,
47 enable_panic_abort_tests: bool,
49 // Check for #![reexport_test_harness_main = "some_name"] which gives the
50 // main test function the name `some_name` without hygiene. This needs to be
51 // unconditional, so that the attribute is still marked as used in
53 let reexport_test_harness_main =
54 attr::first_attr_value_str_by_name(&krate.attrs, sym::reexport_test_harness_main);
56 // Do this here so that the test_runner crate attribute gets marked as used
57 // even in non-test builds
58 let test_runner = get_test_runner(span_diagnostic, &krate);
61 let panic_strategy = match (panic_strategy, enable_panic_abort_tests) {
62 (PanicStrategy::Abort, true) => PanicStrategy::Abort,
63 (PanicStrategy::Abort, false) if panic_strategy == platform_panic_strategy => {
64 // Silently allow compiling with panic=abort on these platforms,
65 // but with old behavior (abort if a test fails).
68 (PanicStrategy::Abort, false) => {
70 "building tests with panic=abort is not supported \
71 without `-Zpanic_abort_tests`",
75 (PanicStrategy::Unwind, _) => PanicStrategy::Unwind,
77 generate_test_harness(
80 reexport_test_harness_main,
89 struct TestHarnessGenerator<'a> {
94 impl<'a> MutVisitor for TestHarnessGenerator<'a> {
95 fn visit_crate(&mut self, c: &mut ast::Crate) {
96 noop_visit_crate(c, self);
98 // Create a main function to run our tests
99 c.module.items.push(mk_main(&mut self.cx));
102 fn flat_map_item(&mut self, i: P<ast::Item>) -> SmallVec<[P<ast::Item>; 1]> {
103 let mut item = i.into_inner();
104 if is_test_case(&item) {
105 debug!("this is a test item");
107 let test = Test { span: item.span, ident: item.ident };
108 self.tests.push(test);
111 // We don't want to recurse into anything other than mods, since
112 // mods or tests inside of functions will break things
113 if let ast::ItemKind::Mod(mut module) = item.kind {
114 let tests = mem::take(&mut self.tests);
115 noop_visit_mod(&mut module, self);
116 let mut tests = mem::replace(&mut self.tests, tests);
118 if !tests.is_empty() {
120 if item.id == ast::DUMMY_NODE_ID { ast::CRATE_NODE_ID } else { item.id };
121 // Create an identifier that will hygienically resolve the test
122 // case name, even in another module.
123 let expn_id = self.cx.ext_cx.resolver.expansion_for_ast_pass(
125 AstPass::TestHarness,
129 for test in &mut tests {
130 // See the comment on `mk_main` for why we're using
131 // `apply_mark` directly.
132 test.ident.span = test.ident.span.apply_mark(expn_id, Transparency::Opaque);
134 self.cx.test_cases.extend(tests);
136 item.kind = ast::ItemKind::Mod(module);
141 fn visit_mac(&mut self, _mac: &mut ast::MacCall) {
146 /// A folder used to remove any entry points (like fn main) because the harness
147 /// generator will provide its own
148 struct EntryPointCleaner {
149 // Current depth in the ast
154 impl MutVisitor for EntryPointCleaner {
155 fn flat_map_item(&mut self, i: P<ast::Item>) -> SmallVec<[P<ast::Item>; 1]> {
157 let item = noop_flat_map_item(i, self).expect_one("noop did something");
160 // Remove any #[main] or #[start] from the AST so it doesn't
161 // clash with the one we're going to add, but mark it as
162 // #[allow(dead_code)] to avoid printing warnings.
163 let item = match entry::entry_point_type(&item, self.depth) {
164 EntryPointType::MainNamed | EntryPointType::MainAttr | EntryPointType::Start => item
165 .map(|ast::Item { id, ident, attrs, kind, vis, span, tokens }| {
166 let allow_ident = Ident::new(sym::allow, self.def_site);
168 attr::mk_nested_word_item(Ident::new(sym::dead_code, self.def_site));
169 let allow_dead_code_item = attr::mk_list_item(allow_ident, vec![dc_nested]);
170 let allow_dead_code = attr::mk_attr_outer(allow_dead_code_item);
173 .filter(|attr| !attr.check_name(sym::main) && !attr.check_name(sym::start))
174 .chain(iter::once(allow_dead_code))
177 ast::Item { id, ident, attrs, kind, vis, span, tokens }
179 EntryPointType::None | EntryPointType::OtherMain => item,
185 fn visit_mac(&mut self, _mac: &mut ast::MacCall) {
190 /// Crawl over the crate, inserting test reexports and the test main function
191 fn generate_test_harness(
193 resolver: &mut dyn ResolverExpand,
194 reexport_test_harness_main: Option<Symbol>,
195 krate: &mut ast::Crate,
197 panic_strategy: PanicStrategy,
198 test_runner: Option<ast::Path>,
200 let mut econfig = ExpansionConfig::default("test".to_string());
201 econfig.features = Some(features);
203 let ext_cx = ExtCtxt::new(sess, econfig, resolver, None);
205 let expn_id = ext_cx.resolver.expansion_for_ast_pass(
207 AstPass::TestHarness,
208 &[sym::main, sym::test, sym::rustc_attrs],
211 let def_site = DUMMY_SP.with_def_site_ctxt(expn_id);
213 // Remove the entry points
214 let mut cleaner = EntryPointCleaner { depth: 0, def_site };
215 cleaner.visit_crate(krate);
221 test_cases: Vec::new(),
222 reexport_test_harness_main,
226 TestHarnessGenerator { cx, tests: Vec::new() }.visit_crate(krate);
229 /// Creates a function item for use as the main function of a test build.
230 /// This function will call the `test_runner` as specified by the crate attribute
232 /// By default this expands to
237 /// extern crate test;
238 /// test::test_main_static(&[
246 /// Most of the Ident have the usual def-site hygiene for the AST pass. The
247 /// exception is the `test_const`s. These have a syntax context that has two
248 /// opaque marks: one from the expansion of `test` or `test_case`, and one
249 /// generated in `TestHarnessGenerator::flat_map_item`. When resolving this
250 /// identifier after failing to find a matching identifier in the root module
251 /// we remove the outer mark, and try resolving at its def-site, which will
252 /// then resolve to `test_const`.
254 /// The expansion here can be controlled by two attributes:
256 /// [`TestCtxt::reexport_test_harness_main`] provides a different name for the `main`
257 /// function and [`TestCtxt::test_runner`] provides a path that replaces
258 /// `test::test_main_static`.
259 fn mk_main(cx: &mut TestCtxt<'_>) -> P<ast::Item> {
260 let sp = cx.def_site;
261 let ecx = &cx.ext_cx;
262 let test_id = Ident::new(sym::test, sp);
264 let runner_name = match cx.panic_strategy {
265 PanicStrategy::Unwind => "test_main_static",
266 PanicStrategy::Abort => "test_main_static_abort",
269 // test::test_main_static(...)
270 let mut test_runner = cx
273 .unwrap_or(ecx.path(sp, vec![test_id, ecx.ident_of(runner_name, sp)]));
275 test_runner.span = sp;
277 let test_main_path_expr = ecx.expr_path(test_runner);
278 let call_test_main = ecx.expr_call(sp, test_main_path_expr, vec![mk_tests_slice(cx, sp)]);
279 let call_test_main = ecx.stmt_expr(call_test_main);
282 let test_extern_stmt =
283 ecx.stmt_item(sp, ecx.item(sp, test_id, vec![], ast::ItemKind::ExternCrate(None)));
286 let main_meta = ecx.meta_word(sp, sym::main);
287 let main_attr = ecx.attribute(main_meta);
289 // pub fn main() { ... }
290 let main_ret_ty = ecx.ty(sp, ast::TyKind::Tup(vec![]));
292 // If no test runner is provided we need to import the test crate
293 let main_body = if cx.test_runner.is_none() {
294 ecx.block(sp, vec![test_extern_stmt, call_test_main])
296 ecx.block(sp, vec![call_test_main])
299 let decl = ecx.fn_decl(vec![], ast::FnRetTy::Ty(main_ret_ty));
300 let sig = ast::FnSig { decl, header: ast::FnHeader::default() };
301 let def = ast::Defaultness::Final;
302 let main = ast::ItemKind::Fn(def, sig, ast::Generics::default(), Some(main_body));
304 // Honor the reexport_test_harness_main attribute
305 let main_id = match cx.reexport_test_harness_main {
306 Some(sym) => Ident::new(sym, sp.with_ctxt(SyntaxContext::root())),
307 None => Ident::new(sym::main, sp),
310 let main = P(ast::Item {
312 attrs: vec![main_attr],
313 id: ast::DUMMY_NODE_ID,
315 vis: respan(sp, ast::VisibilityKind::Public),
320 // Integrate the new item into existing module structures.
321 let main = AstFragment::Items(smallvec![main]);
322 cx.ext_cx.monotonic_expander().fully_expand_fragment(main).make_items().pop().unwrap()
325 /// Creates a slice containing every test like so:
326 /// &[&test1, &test2]
327 fn mk_tests_slice(cx: &TestCtxt<'_>, sp: Span) -> P<ast::Expr> {
328 debug!("building test vector from {} tests", cx.test_cases.len());
329 let ecx = &cx.ext_cx;
336 ecx.expr_addr_of(test.span, ecx.expr_path(ecx.path(test.span, vec![test.ident])))
342 fn is_test_case(i: &ast::Item) -> bool {
343 attr::contains_name(&i.attrs, sym::rustc_test_marker)
346 fn get_test_runner(sd: &rustc_errors::Handler, krate: &ast::Crate) -> Option<ast::Path> {
347 let test_attr = attr::find_by_name(&krate.attrs, sym::test_runner)?;
348 let meta_list = test_attr.meta_item_list()?;
349 let span = test_attr.span;
351 [single] => match single.meta_item() {
352 Some(meta_item) if meta_item.is_word() => return Some(meta_item.path.clone()),
353 _ => sd.struct_span_err(span, "`test_runner` argument must be a path").emit(),
355 _ => sd.struct_span_err(span, "`#![test_runner(..)]` accepts exactly 1 argument").emit(),