adjust how backtraces get rendered; always show thread name when there are multiple threads

Author: RalfJung

src/diagnostics.rs

@@ -250,7 +250,7 @@ pub fn report_result<'tcx>(
             StackedBorrowsUb { .. } | TreeBorrowsUb { .. } | DataRace { .. } =>
                 Some("Undefined Behavior"),
             LocalDeadlock => {
-                labels.push(format!("this thread got stuck here"));
+                labels.push(format!("thread got stuck here"));
                 None
             }
             GlobalDeadlock => {
@@ -264,10 +264,7 @@ pub fn report_result<'tcx>(
                     report_msg(
                         DiagLevel::Error,
                         format!("the evaluated program deadlocked"),
-                        vec![format!(
-                            "thread `{}` got stuck here",
-                            ecx.machine.threads.get_thread_display_name(thread)
-                        )],
+                        vec![format!("thread got stuck here")],
                         vec![],
                         vec![],
                         &stacktrace,
@@ -563,6 +560,7 @@ pub fn report_msg<'tcx>(
         None =>
             match thread {
                 Some(thread_id) => machine.threads.thread_ref(thread_id).origin_span,
+                // This fallback is super rare, but can happen e.g. when `main` has the wrong ABI
                 None => DUMMY_SP,
             },
     };
@@ -608,36 +606,53 @@ pub fn report_msg<'tcx>(
     }
 
     // Add backtrace
-    if stacktrace.len() > 1 {
-        let mut backtrace_title = String::from("BACKTRACE");
-        if extra_span {
-            write!(backtrace_title, " (of the first span)").unwrap();
+    if let Some((first, rest)) = stacktrace.split_first() {
+        // Start with the function and thread that contain the first span.
+        let mut fn_and_thread = String::new();
+        // Only print thread name if there are multiple threads.
+        if let Some(thread) = thread
+            && machine.threads.get_total_thread_count() > 1
+        {
+            write!(
+                fn_and_thread,
+                "on thread `{}`",
+                machine.threads.get_thread_display_name(thread)
+            )
+            .unwrap();
+        }
+        // Only print function name if we show a backtrace
+        if rest.len() > 0 {
+            if !fn_and_thread.is_empty() {
+                fn_and_thread.push_str(", ");
+            }
+            write!(fn_and_thread, "{first}").unwrap();
         }
-        if let Some(thread) = thread {
-            let thread_name = machine.threads.get_thread_display_name(thread);
-            if thread_name != "main" {
-                // Only print thread name if it is not `main`.
-                write!(backtrace_title, " on thread `{thread_name}`").unwrap();
-            };
+        if !fn_and_thread.is_empty() {
+            if extra_span && rest.len() > 0 {
+                // Print a `span_note` as otherwise the backtrace looks attached to the last
+                // `span_help`. We somewhat arbitrarily use the span of the surrounding function.
+                err.span_note(
+                    machine.tcx.def_span(first.instance.def_id()),
+                    format!("{level} occurred {fn_and_thread}"),
+                );
+            } else {
+                err.note(format!("this is {fn_and_thread}"));
+            }
         }
-        write!(backtrace_title, ":").unwrap();
-        err.note(backtrace_title);
-        for (idx, frame_info) in stacktrace.iter().enumerate() {
+        // Continue with where that function got called.
+        for frame_info in rest.iter() {
             let is_local = machine.is_local(frame_info.instance);
             // No span for non-local frames and the first frame (which is the error site).
-            if is_local && idx > 0 {
-                err.subdiagnostic(frame_info.as_note(machine.tcx));
+            if is_local {
+                err.span_note(frame_info.span, format!("which got called {frame_info}"));
             } else {
                 let sm = sess.source_map();
                 let span = sm.span_to_embeddable_string(frame_info.span);
-                err.note(format!("{frame_info} at {span}"));
+                err.note(format!("which got called {frame_info} (at {span})"));
             }
         }
-    } else if stacktrace.len() == 0 && !span.is_dummy() {
-        err.note(format!(
-            "this {} occurred while pushing a call frame onto an empty stack",
-            level.to_str()
-        ));
+    } else if !span.is_dummy() {
+        err.note(format!("this {level} occurred while pushing a call frame onto an empty stack"));
         err.note("the span indicates which code caused the function to be called, but may not be the literal call site");
     }
 

tests/fail-dep/concurrency/apple_os_unfair_lock_move_with_queue.stderr

@@ -6,6 +6,7 @@ LL |             let _val = atomic_ref.load(Ordering::Relaxed);
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
+   = note: this is on thread `unnamed-ID`
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 

tests/fail-dep/concurrency/libc_pthread_cond_move.init.stderr

@@ -6,9 +6,8 @@ LL |         libc::pthread_cond_destroy(cond2.as_mut_ptr());
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
-   = note: BACKTRACE:
-   = note: inside `check` at tests/fail-dep/concurrency/libc_pthread_cond_move.rs:LL:CC
-note: inside `main`
+   = note: this is inside `check`
+note: which got called inside `main`
   --> tests/fail-dep/concurrency/libc_pthread_cond_move.rs:LL:CC
    |
 LL |     check()

tests/fail-dep/concurrency/libc_pthread_cond_move.static_initializer.stderr

@@ -6,9 +6,8 @@ LL |         libc::pthread_cond_destroy(&mut cond2 as *mut _);
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
-   = note: BACKTRACE:
-   = note: inside `check` at tests/fail-dep/concurrency/libc_pthread_cond_move.rs:LL:CC
-note: inside `main`
+   = note: this is inside `check`
+note: which got called inside `main`
   --> tests/fail-dep/concurrency/libc_pthread_cond_move.rs:LL:CC
    |
 LL |     check()

tests/fail-dep/concurrency/libc_pthread_join_detached.stderr

@@ -6,6 +6,7 @@ LL |         assert_eq!(libc::pthread_join(native, ptr::null_mut()), 0);
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
+   = note: this is on thread `main`
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 

tests/fail-dep/concurrency/libc_pthread_join_joined.stderr

@@ -6,6 +6,7 @@ LL | ...   assert_eq!(libc::pthread_join(native, ptr::null_mut()), 0);
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
+   = note: this is on thread `main`
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 

tests/fail-dep/concurrency/libc_pthread_join_main.stderr

@@ -6,6 +6,7 @@ LL | ...   assert_eq!(libc::pthread_join(thread_id, ptr::null_mut()), 0);
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
+   = note: this is on thread `unnamed-ID`
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 

tests/fail-dep/concurrency/libc_pthread_join_multiple.stderr

@@ -6,6 +6,7 @@ LL | ...   assert_eq!(libc::pthread_join(native_copy, ptr::null_mut()), 0);
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
+   = note: this is on thread `unnamed-ID`
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 

tests/fail-dep/concurrency/libc_pthread_join_self.stderr

@@ -6,6 +6,7 @@ LL |             assert_eq!(libc::pthread_join(native, ptr::null_mut()), 0);
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
+   = note: this is on thread `unnamed-ID`
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 

tests/fail-dep/concurrency/libc_pthread_mutex_deadlock.stderr

@@ -2,13 +2,12 @@ error: the evaluated program deadlocked
   --> RUSTLIB/std/src/sys/thread/PLATFORM.rs:LL:CC
    |
 LL |         let ret = unsafe { libc::pthread_join(id, ptr::null_mut()) };
-   |                                                                  ^ thread `main` got stuck here
+   |                                                                  ^ thread got stuck here
    |
-   = note: BACKTRACE:
-   = note: inside `std::sys::thread::PLATFORM::Thread::join` at RUSTLIB/std/src/sys/thread/PLATFORM.rs:LL:CC
-   = note: inside `std::thread::lifecycle::JoinInner::<'_, ()>::join` at RUSTLIB/std/src/thread/lifecycle.rs:LL:CC
-   = note: inside `std::thread::JoinHandle::<()>::join` at RUSTLIB/std/src/thread/join_handle.rs:LL:CC
-note: inside `main`
+   = note: this is on thread `main`, inside `std::sys::thread::PLATFORM::Thread::join`
+   = note: which got called inside `std::thread::lifecycle::JoinInner::<'_, ()>::join` (at RUSTLIB/std/src/thread/lifecycle.rs:LL:CC)
+   = note: which got called inside `std::thread::JoinHandle::<()>::join` (at RUSTLIB/std/src/thread/join_handle.rs:LL:CC)
+note: which got called inside `main`
   --> tests/fail-dep/concurrency/libc_pthread_mutex_deadlock.rs:LL:CC
    |
 LL | /         thread::spawn(move || {
@@ -21,7 +20,9 @@ error: the evaluated program deadlocked
   --> tests/fail-dep/concurrency/libc_pthread_mutex_deadlock.rs:LL:CC
    |
 LL |             assert_eq!(libc::pthread_mutex_lock(lock_copy.0.get() as *mut _), 0);
-   |                                                                            ^ thread `unnamed-ID` got stuck here
+   |                                                                            ^ thread got stuck here
+   |
+   = note: this is on thread `unnamed-ID`
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace