1 /// The expansion from a test function to the appropriate test struct for libtest
2 /// Ideally, this code would be in libtest but for efficiency and error messages it lives here.
3 use crate::util::{check_builtin_macro_attribute, warn_on_duplicate_attribute};
8 use rustc_ast_pretty::pprust;
9 use rustc_errors::Applicability;
10 use rustc_expand::base::*;
11 use rustc_session::Session;
12 use rustc_span::symbol::{sym, Ident, Symbol};
17 // #[test_case] is used by custom test authors to mark tests
18 // When building for test, it needs to make the item public and gensym the name
19 // Otherwise, we'll omit the item. This behavior means that any item annotated
20 // with #[test_case] is never addressable.
22 // We mark item with an inert attribute "rustc_test_marker" which the test generation
23 // logic will pick up on.
24 pub fn expand_test_case(
25 ecx: &mut ExtCtxt<'_>,
27 meta_item: &ast::MetaItem,
28 anno_item: Annotatable,
29 ) -> Vec<Annotatable> {
30 check_builtin_macro_attribute(ecx, meta_item, sym::test_case);
31 warn_on_duplicate_attribute(&ecx, &anno_item, sym::test_case);
33 if !ecx.ecfg.should_test {
37 let sp = ecx.with_def_site_ctxt(attr_sp);
38 let mut item = anno_item.expect_item();
39 item = item.map(|mut item| {
40 item.vis = ast::Visibility {
42 kind: ast::VisibilityKind::Public,
45 item.ident.span = item.ident.span.with_ctxt(sp.ctxt());
46 item.attrs.push(ecx.attribute(ecx.meta_word(sp, sym::rustc_test_marker)));
50 return vec![Annotatable::Item(item)];
56 meta_item: &ast::MetaItem,
58 ) -> Vec<Annotatable> {
59 check_builtin_macro_attribute(cx, meta_item, sym::test);
60 warn_on_duplicate_attribute(&cx, &item, sym::test);
61 expand_test_or_bench(cx, attr_sp, item, false)
67 meta_item: &ast::MetaItem,
69 ) -> Vec<Annotatable> {
70 check_builtin_macro_attribute(cx, meta_item, sym::bench);
71 warn_on_duplicate_attribute(&cx, &item, sym::bench);
72 expand_test_or_bench(cx, attr_sp, item, true)
75 pub fn expand_test_or_bench(
80 ) -> Vec<Annotatable> {
81 // If we're not in test configuration, remove the annotated item
82 if !cx.ecfg.should_test {
86 let (item, is_stmt) = match item {
87 Annotatable::Item(i) => (i, false),
88 Annotatable::Stmt(stmt) if matches!(stmt.kind, ast::StmtKind::Item(_)) => {
89 // FIXME: Use an 'if let' guard once they are implemented
90 if let ast::StmtKind::Item(i) = stmt.into_inner().kind {
99 "`#[test]` attribute is only allowed on non associated functions",
106 // Note: non-associated fn items are already handled by `expand_test_or_bench`
107 if !matches!(item.kind, ast::ItemKind::Fn(_)) {
113 "the `#[test]` attribute may only be used on a non-associated function",
115 .note("the `#[test]` macro causes a a function to be run on a test and has no effect on non-functions")
116 .span_label(item.span, format!("expected a non-associated function, found {} {}", item.kind.article(), item.kind.descr()))
117 .span_suggestion(attr_sp, "replace with conditional compilation to make the item only exist when tests are being run", String::from("#[cfg(test)]"), Applicability::MaybeIncorrect)
120 return vec![Annotatable::Item(item)];
123 // has_*_signature will report any errors in the type so compilation
124 // will fail. We shouldn't try to expand in this case because the errors
125 // would be spurious.
126 if (!is_bench && !has_test_signature(cx, &item))
127 || (is_bench && !has_bench_signature(cx, &item))
129 return vec![Annotatable::Item(item)];
132 let (sp, attr_sp) = (cx.with_def_site_ctxt(item.span), cx.with_def_site_ctxt(attr_sp));
134 let test_id = Ident::new(sym::test, attr_sp);
136 // creates test::$name
137 let test_path = |name| cx.path(sp, vec![test_id, Ident::from_str_and_span(name, sp)]);
139 // creates test::ShouldPanic::$name
140 let should_panic_path = |name| {
145 Ident::from_str_and_span("ShouldPanic", sp),
146 Ident::from_str_and_span(name, sp),
151 // creates test::TestType::$name
152 let test_type_path = |name| {
157 Ident::from_str_and_span("TestType", sp),
158 Ident::from_str_and_span(name, sp),
163 // creates $name: $expr
164 let field = |name, expr| cx.field_imm(sp, Ident::from_str_and_span(name, sp), expr);
166 let test_fn = if is_bench {
167 // A simple ident for a lambda
168 let b = Ident::from_str_and_span("b", attr_sp);
172 cx.expr_path(test_path("StaticBenchFn")),
174 // |b| self::test::assert_test_result(
179 cx.expr_path(test_path("assert_test_result")),
181 // super::$test_fn(b)
184 cx.expr_path(cx.path(sp, vec![item.ident])),
185 vec![cx.expr_ident(sp, b)],
196 cx.expr_path(test_path("StaticTestFn")),
201 // test::assert_test_result(
204 cx.expr_path(test_path("assert_test_result")),
207 cx.expr_call(sp, cx.expr_path(cx.path(sp, vec![item.ident])), vec![]), // )
215 let mut test_const = cx.item(
217 Ident::new(item.ident.name, sp),
220 cx.attribute(attr::mk_list_item(
221 Ident::new(sym::cfg, attr_sp),
222 vec![attr::mk_nested_word_item(Ident::new(sym::test, attr_sp))],
224 // #[rustc_test_marker]
225 cx.attribute(cx.meta_word(attr_sp, sym::rustc_test_marker)),
227 // const $ident: test::TestDescAndFn =
228 ast::ItemKind::Const(
229 ast::Defaultness::Final,
230 cx.ty(sp, ast::TyKind::Path(None, test_path("TestDescAndFn"))),
231 // test::TestDescAndFn {
235 test_path("TestDescAndFn"),
237 // desc: test::TestDesc {
242 test_path("TestDesc"),
244 // name: "path::to::test"
249 cx.expr_path(test_path("StaticTestName")),
252 Symbol::intern(&item_path(
253 // skip the name of the root module
254 &cx.current_expansion.module.mod_path[1..],
260 // ignore: true | false
263 cx.expr_bool(sp, should_ignore(&cx.sess, &item)),
265 // compile_fail: true | false
266 field("compile_fail", cx.expr_bool(sp, false)),
267 // no_run: true | false
268 field("no_run", cx.expr_bool(sp, false)),
272 match should_panic(cx, &item) {
273 // test::ShouldPanic::No
275 cx.expr_path(should_panic_path("No"))
277 // test::ShouldPanic::Yes
278 ShouldPanic::Yes(None) => {
279 cx.expr_path(should_panic_path("Yes"))
281 // test::ShouldPanic::YesWithMessage("...")
282 ShouldPanic::Yes(Some(sym)) => cx.expr_call(
284 cx.expr_path(should_panic_path("YesWithMessage")),
285 vec![cx.expr_str(sp, sym)],
292 match test_type(cx) {
293 // test::TestType::UnitTest
294 TestType::UnitTest => {
295 cx.expr_path(test_type_path("UnitTest"))
297 // test::TestType::IntegrationTest
298 TestType::IntegrationTest => {
299 cx.expr_path(test_type_path("IntegrationTest"))
301 // test::TestPath::Unknown
302 TestType::Unknown => {
303 cx.expr_path(test_type_path("Unknown"))
311 // testfn: test::StaticTestFn(...) | test::StaticBenchFn(...)
312 field("testfn", test_fn), // }
318 test_const = test_const.map(|mut tc| {
319 tc.vis.kind = ast::VisibilityKind::Public;
324 let test_extern = cx.item(sp, test_id, vec![], ast::ItemKind::ExternCrate(None));
326 tracing::debug!("synthetic test item:\n{}\n", pprust::item_to_string(&test_const));
330 // Access to libtest under a hygienic name
331 Annotatable::Stmt(P(cx.stmt_item(sp, test_extern))),
332 // The generated test case
333 Annotatable::Stmt(P(cx.stmt_item(sp, test_const))),
335 Annotatable::Stmt(P(cx.stmt_item(sp, item))),
339 // Access to libtest under a hygienic name
340 Annotatable::Item(test_extern),
341 // The generated test case
342 Annotatable::Item(test_const),
344 Annotatable::Item(item),
349 fn item_path(mod_path: &[Ident], item_ident: &Ident) -> String {
352 .chain(iter::once(item_ident))
353 .map(|x| x.to_string())
354 .collect::<Vec<String>>()
363 fn should_ignore(sess: &Session, i: &ast::Item) -> bool {
364 sess.contains_name(&i.attrs, sym::ignore)
367 fn should_panic(cx: &ExtCtxt<'_>, i: &ast::Item) -> ShouldPanic {
368 match cx.sess.find_by_name(&i.attrs, sym::should_panic) {
370 let sd = &cx.sess.parse_sess.span_diagnostic;
372 match attr.meta_item_list() {
373 // Handle #[should_panic(expected = "foo")]
377 .find(|mi| mi.has_name(sym::expected))
378 .and_then(|mi| mi.meta_item())
379 .and_then(|mi| mi.value_str());
380 if list.len() != 1 || msg.is_none() {
383 "argument must be of the form: \
384 `expected = \"error message\"`",
387 "errors in this attribute were erroneously \
388 allowed and will become a hard error in a \
392 ShouldPanic::Yes(None)
394 ShouldPanic::Yes(msg)
397 // Handle #[should_panic] and #[should_panic = "expected"]
398 None => ShouldPanic::Yes(attr.value_str()),
401 None => ShouldPanic::No,
411 /// Attempts to determine the type of test.
412 /// Since doctests are created without macro expanding, only possible variants here
413 /// are `UnitTest`, `IntegrationTest` or `Unknown`.
414 fn test_type(cx: &ExtCtxt<'_>) -> TestType {
415 // Root path from context contains the topmost sources directory of the crate.
416 // I.e., for `project` with sources in `src` and tests in `tests` folders
417 // (no matter how many nested folders lie inside),
418 // there will be two different root paths: `/project/src` and `/project/tests`.
419 let crate_path = cx.root_path.as_path();
421 if crate_path.ends_with("src") {
422 // `/src` folder contains unit-tests.
424 } else if crate_path.ends_with("tests") {
425 // `/tests` folder contains integration tests.
426 TestType::IntegrationTest
428 // Crate layout doesn't match expected one, test type is unknown.
433 fn has_test_signature(cx: &ExtCtxt<'_>, i: &ast::Item) -> bool {
434 let has_should_panic_attr = cx.sess.contains_name(&i.attrs, sym::should_panic);
435 let sd = &cx.sess.parse_sess.span_diagnostic;
436 if let ast::ItemKind::Fn(box ast::Fn { ref sig, ref generics, .. }) = i.kind {
437 if let ast::Unsafe::Yes(span) = sig.header.unsafety {
438 sd.struct_span_err(i.span, "unsafe functions cannot be used for tests")
439 .span_label(span, "`unsafe` because of this")
443 if let ast::Async::Yes { span, .. } = sig.header.asyncness {
444 sd.struct_span_err(i.span, "async functions cannot be used for tests")
445 .span_label(span, "`async` because of this")
450 // If the termination trait is active, the compiler will check that the output
451 // type implements the `Termination` trait as `libtest` enforces that.
452 let has_output = match sig.decl.output {
453 ast::FnRetTy::Default(..) => false,
454 ast::FnRetTy::Ty(ref t) if t.kind.is_unit() => false,
458 if !sig.decl.inputs.is_empty() {
459 sd.span_err(i.span, "functions used as tests can not have any arguments");
463 match (has_output, has_should_panic_attr) {
465 sd.span_err(i.span, "functions using `#[should_panic]` must return `()`");
469 if !generics.params.is_empty() {
470 sd.span_err(i.span, "functions used as tests must have signature fn() -> ()");
479 // should be unreachable because `is_test_fn_item` should catch all non-fn items
484 fn has_bench_signature(cx: &ExtCtxt<'_>, i: &ast::Item) -> bool {
485 let has_sig = if let ast::ItemKind::Fn(box ast::Fn { ref sig, .. }) = i.kind {
486 // N.B., inadequate check, but we're running
487 // well before resolve, can't get too deep.
488 sig.decl.inputs.len() == 1
494 cx.sess.parse_sess.span_diagnostic.span_err(
496 "functions used as benches must have \
497 signature `fn(&mut Bencher) -> impl Termination`",