rearrange wording in errors, pass lines as one argument to error display

Author: saethlin

src/diagnostics.rs

@@ -134,7 +134,9 @@ pub fn report_error<'tcx, 'mir>(
 ) -> Option<i64> {
     use InterpError::*;
 
-    let (title, labels, helps) = match &e.kind() {
+    let mut msg = vec![];
+
+    let (title, helps) = match &e.kind() {
         MachineStop(info) => {
             let info = info.downcast_ref::<TerminationInfo>().expect("invalid MachineStop payload");
             use TerminationInfo::*;
@@ -146,7 +148,6 @@ pub fn report_error<'tcx, 'mir>(
                 Deadlock => Some("deadlock"),
                 MultipleSymbolDefinitions { .. } | SymbolShimClashing { .. } => None,
             };
-            let mut labels = vec![];
             #[rustfmt::skip]
             let helps = match info {
                 UnsupportedInIsolation(_) =>
@@ -155,9 +156,7 @@ pub fn report_error<'tcx, 'mir>(
                         (None, format!("or pass `-Zmiri-isolation-error=warn to configure Miri to return an error code from isolated operations (if supported for that operation) and continue with a warning")),
                     ],
                 ExperimentalUb { url, help, .. } => {
-                    if let Some(help) = help {
-                        labels.push(help.clone());
-                    }
+                    msg.extend(help.clone());
                     vec![
                         (None, format!("this indicates a potential bug in the program: it performed an invalid operation, but the rules it violated are still experimental")),
                         (None, format!("see {} for further information", url))
@@ -172,7 +171,7 @@ pub fn report_error<'tcx, 'mir>(
                     vec![(Some(*span), format!("the `{}` symbol is defined here", link_name))],
                 _ => vec![],
             };
-            (title, labels, helps)
+            (title, helps)
         }
         _ => {
             #[rustfmt::skip]
@@ -210,20 +209,19 @@ pub fn report_error<'tcx, 'mir>(
                     ],
                 _ => vec![],
             };
-            (Some(title), vec![], helps)
+            (Some(title), helps)
         }
     };
 
     let stacktrace = ecx.generate_stacktrace();
     let (stacktrace, was_pruned) = prune_stacktrace(ecx, stacktrace);
     e.print_backtrace();
-    let msg = e.to_string();
+    msg.insert(0, e.to_string());
     report_msg(
         *ecx.tcx,
         DiagLevel::Error,
-        &if let Some(title) = title { format!("{}: {}", title, msg) } else { msg.clone() },
+        &if let Some(title) = title { format!("{}: {}", title, msg[0]) } else { msg[0].clone() },
         msg,
-        labels,
         helps,
         &stacktrace,
     );
@@ -263,12 +261,14 @@ pub fn report_error<'tcx, 'mir>(
 
 /// Report an error or note (depending on the `error` argument) with the given stacktrace.
 /// Also emits a full stacktrace of the interpreter stack.
+/// We want to present a multi-line span message for some errors. Diagnostics do not support this
+/// directly, so we pass the lines as a `Vec<String>` and display each line after the first with an
+/// additional `span_label` or `note` call.
 fn report_msg<'tcx>(
     tcx: TyCtxt<'tcx>,
     diag_level: DiagLevel,
     title: &str,
-    span_msg: String,
-    labels: Vec<String>,
+    span_msg: Vec<String>,
     mut helps: Vec<(Option<SpanData>, String)>,
     stacktrace: &[FrameInfo<'tcx>],
 ) {
@@ -279,18 +279,19 @@ fn report_msg<'tcx>(
         DiagLevel::Note => tcx.sess.diagnostic().span_note_diag(span, title),
     };
 
+    let first_line = span_msg.get(0).cloned().unwrap_or_default();
     // Show main message.
     if span != DUMMY_SP {
-        err.span_label(span, span_msg);
-        for label in labels {
-            err.span_label(span, label);
+        err.span_label(span, first_line);
+        for line in span_msg.iter().skip(1) {
+            err.span_label(span, line);
         }
     } else {
         // Make sure we show the message even when it is a dummy span.
-        err.note(&span_msg);
+        err.note(&first_line);
         err.note("(no span available)");
-        for label in labels {
-            err.note(&label);
+        for line in span_msg.iter().skip(1) {
+            err.note(&line);
         }
     }
 
@@ -428,7 +429,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
                     _ => ("tracking was triggered", DiagLevel::Note),
                 };
 
-                report_msg(*this.tcx, diag_level, title, msg, vec![], vec![], &stacktrace);
+                report_msg(*this.tcx, diag_level, title, vec![msg], vec![], &stacktrace);
             }
         });
     }

src/stacked_borrows.rs

@@ -341,8 +341,8 @@ impl<'tcx> Stack {
 
     /// Test if a memory `access` using pointer tagged `tag` is granted.
     /// If yes, return the index of the item that granted it.
-    /// `range` refers the entire operation, and `offset` refers to the specific location in
-    /// `range` that we are currently checking.
+    /// `range` refers the entire operation, and `offset` refers to the specific offset into the
+    /// allocation that we are currently checking.
     fn access(
         &mut self,
         access: AccessKind,
@@ -484,11 +484,11 @@ impl<'tcx> Stack {
         error_offset: Size,
     ) -> InterpError<'static> {
         let action = format!(
-            "trying to reborrow {:?}[{:#x}] with {:?} permission via tag {:?}",
+            "trying to reborrow {:?} for {:?} permission at {}[{:#x}]",
+            derived_from,
+            new.perm,
             alloc_id,
             error_offset.bytes(),
-            new.perm,
-            derived_from,
         );
         err_sb_ub(
             format!("{}{}", action, self.error_cause(derived_from)),
@@ -506,11 +506,11 @@ impl<'tcx> Stack {
         error_offset: Size,
     ) -> InterpError<'static> {
         let action = format!(
-            "attempting a {} at {}[{:#x}] via tag {:?}",
+            "attempting a {} using {:?} at {}[{:#x}]",
             access,
+            tag,
             alloc_id,
             error_offset.bytes(),
-            tag,
         );
         err_sb_ub(
             format!("{}{}", action, self.error_cause(tag)),
@@ -534,9 +534,9 @@ impl<'tcx> Stack {
 
     fn error_cause(&self, tag: SbTag) -> &'static str {
         if self.borrows.iter().any(|item| item.tag == tag && item.perm != Permission::Disabled) {
-            ", but that tag only grants SharedReadOnly permission for this memory"
+            ", but that tag only grants SharedReadOnly permission for this location"
         } else {
-            ", but that tag does not exist in the borrow stack for this memory"
+            ", but that tag does not exist in the borrow stack for this location"
         }
     }
 }