Report line number of test when should_panic test failed

Signed-off-by: xizheyin <xizheyin@smail.nju.edu.cn>

Author: xizheyin

compiler/rustc_builtin_macros/src/test.rs

@@ -267,6 +267,8 @@ pub(crate) fn expand_test_or_bench(
 
     let location_info = get_location_info(cx, &item);
 
+    let span_sym = Symbol::intern(&format!("{:?}", sp).split(' ').next().unwrap_or_default());
+
     let mut test_const =
         cx.item(
             sp,
@@ -336,14 +338,16 @@ pub(crate) fn expand_test_or_bench(
                                         cx.expr_path(should_panic_path("No"))
                                     }
                                     // test::ShouldPanic::Yes
-                                    ShouldPanic::Yes(None) => {
-                                        cx.expr_path(should_panic_path("Yes"))
-                                    }
+                                    ShouldPanic::Yes(None) => cx.expr_call(
+                                        sp,
+                                        cx.expr_path(should_panic_path("Yes")),
+                                        thin_vec![cx.expr_str(sp, span_sym)],
+                                    ),
                                     // test::ShouldPanic::YesWithMessage("...")
                                     ShouldPanic::Yes(Some(sym)) => cx.expr_call(
                                         sp,
                                         cx.expr_path(should_panic_path("YesWithMessage")),
-                                        thin_vec![cx.expr_str(sp, sym)],
+                                        thin_vec![cx.expr_str(sp, sym), cx.expr_str(sp, span_sym)],
                                     ),
                                 },),
                                 // test_type: ...

library/test/src/options.rs

@@ -11,8 +11,8 @@ pub(crate) enum BenchMode {
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
 pub enum ShouldPanic {
     No,
-    Yes,
-    YesWithMessage(&'static str),
+    Yes(&'static str),
+    YesWithMessage(&'static str, &'static str),
 }
 
 /// Whether should console output be colored or not

library/test/src/test_result.rs

@@ -46,8 +46,8 @@ pub(crate) fn calc_result<'a>(
     exec_time: Option<&time::TestExecTime>,
 ) -> TestResult {
     let result = match (&desc.should_panic, task_result) {
-        (&ShouldPanic::No, Ok(())) | (&ShouldPanic::Yes, Err(_)) => TestResult::TrOk,
-        (&ShouldPanic::YesWithMessage(msg), Err(err)) => {
+        (&ShouldPanic::No, Ok(())) | (&ShouldPanic::Yes(_), Err(_)) => TestResult::TrOk,
+        (&ShouldPanic::YesWithMessage(msg, _), Err(err)) => {
             let maybe_panic_str = err
                 .downcast_ref::<String>()
                 .map(|e| &**e)
@@ -71,8 +71,8 @@ pub(crate) fn calc_result<'a>(
                 ))
             }
         }
-        (&ShouldPanic::Yes, Ok(())) | (&ShouldPanic::YesWithMessage(_), Ok(())) => {
-            TestResult::TrFailedMsg("test did not panic as expected".to_string())
+        (&ShouldPanic::Yes(span), Ok(())) | (&ShouldPanic::YesWithMessage(_, span), Ok(())) => {
+            TestResult::TrFailedMsg(format!("test did not panic as expected at {}", span))
         }
         _ => TestResult::TrFailed,
     };

library/test/src/tests.rs

@@ -149,7 +149,7 @@ fn test_should_panic() {
             start_col: 0,
             end_line: 0,
             end_col: 0,
-            should_panic: ShouldPanic::Yes,
+            should_panic: ShouldPanic::Yes(""),
             compile_fail: false,
             no_run: false,
             test_type: TestType::Unknown,

library/test/src/types.rs

@@ -230,7 +230,7 @@ impl TestDesc {
             return None;
         }
         match self.should_panic {
-            options::ShouldPanic::Yes | options::ShouldPanic::YesWithMessage(_) => {
+            options::ShouldPanic::Yes(_) | options::ShouldPanic::YesWithMessage(_, _) => {
                 return Some("should panic");
             }
             options::ShouldPanic::No => {}
@@ -274,7 +274,7 @@ impl TestDescAndFn {
                 compile_fail: false,
                 no_run,
                 should_panic: if should_panic {
-                    options::ShouldPanic::Yes
+                    options::ShouldPanic::Yes("")
                 } else {
                     options::ShouldPanic::No
                 },

src/tools/compiletest/src/header.rs

@@ -1412,7 +1412,7 @@ pub fn make_test_description<R: Read>(
     // If desired, we could add a `should-fail-pretty` annotation.
     let should_panic = match config.mode {
         crate::common::Pretty => test::ShouldPanic::No,
-        _ if should_fail => test::ShouldPanic::Yes,
+        _ if should_fail => test::ShouldPanic::Yes(""),
         _ => test::ShouldPanic::No,
     };
 

tests/ui/test-should-panic.rs

@@ -0,0 +1,30 @@
+//@ run-fail
+//@ check-run-results
+//@ compile-flags: --test
+
+
+#[test]
+#[should_panic]
+fn do_panic1() {
+    panic!("Panic!");
+}
+
+#[test]
+#[should_panic = "SubString"]
+fn do_panic2() {
+    // DON'T PANIC
+    panic!("SubString");
+}
+
+#[test]
+#[should_panic]
+fn dont_panic1() {
+    // DON'T PANIC
+}
+
+
+#[test]
+#[should_panic = "SubString"]
+fn dont_panic2() {
+    // DON'T PANIC
+}

tests/ui/test-should-panic.run.stdout

@@ -0,0 +1,20 @@
+
+running 4 tests
+test dont_panic2 - should panic ... FAILED
+test dont_panic1 - should panic ... FAILED
+test do_panic2 - should panic ... ok
+test do_panic1 - should panic ... ok
+
+failures:
+
+---- dont_panic2 stdout ----
+note: test did not panic as expected at $DIR/test-should-panic.rs:28:1:
+---- dont_panic1 stdout ----
+note: test did not panic as expected at $DIR/test-should-panic.rs:21:1:
+
+failures:
+    dont_panic1
+    dont_panic2
+
+test result: FAILED. 2 passed; 2 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
+