we don't need HexRange any more

Author: RalfJung

src/diagnostics.rs

@@ -8,7 +8,6 @@ use rustc_middle::ty;
 use rustc_span::{source_map::DUMMY_SP, Span, SpanData, Symbol};
 use rustc_target::abi::{Align, Size};
 
-use crate::helpers::HexRange;
 use crate::stacked_borrows::{diagnostics::TagHistory, AccessKind};
 use crate::*;
 
@@ -184,14 +183,14 @@ pub fn report_error<'tcx, 'mir>(
                     ];
                     match history {
                         Some(TagHistory::Tagged {tag, created: (created_range, created_span), invalidated, protected }) => {
-                            let msg = format!("{:?} was created by a retag at offsets {}", tag, HexRange(*created_range));
+                            let msg = format!("{tag:?} was created by a retag at offsets {created_range:?}");
                             helps.push((Some(*created_span), msg));
                             if let Some((invalidated_range, invalidated_span)) = invalidated {
-                                let msg = format!("{:?} was later invalidated at offsets {}", tag, HexRange(*invalidated_range));
+                                let msg = format!("{tag:?} was later invalidated at offsets {invalidated_range:?}");
                                 helps.push((Some(*invalidated_span), msg));
                             }
                             if let Some((protecting_tag, protecting_tag_span, protection_span)) = protected {
-                                helps.push((Some(*protecting_tag_span), format!("{:?} was protected due to {:?} which was created here", tag, protecting_tag)));
+                                helps.push((Some(*protecting_tag_span), format!("{tag:?} was protected due to {protecting_tag:?} which was created here")));
                                 helps.push((Some(*protection_span), format!("this protector is live for this call")));
                             }
                         }
@@ -448,32 +447,38 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
             for e in diagnostics.drain(..) {
                 use NonHaltingDiagnostic::*;
                 let msg = match e {
-                    CreatedPointerTag(tag, None) => format!("created tag {tag:?}"),
+                    CreatedPointerTag(tag, None) =>
+                        format!("created tag {tag:?}"),
                     CreatedPointerTag(tag, Some((alloc_id, range))) =>
-                        format!("created tag {tag:?} at {alloc_id:?}{}", HexRange(range)),
+                        format!("created tag {tag:?} at {alloc_id:?}{range:?}"),
                     PoppedPointerTag(item, tag) =>
                         match tag {
                             None =>
                                 format!(
-                                    "popped tracked tag for item {:?} due to deallocation",
-                                    item
+                                    "popped tracked tag for item {item:?} due to deallocation",
                                 ),
                             Some((tag, access)) => {
                                 format!(
-                                    "popped tracked tag for item {:?} due to {:?} access for {:?}",
-                                    item, access, tag
+                                    "popped tracked tag for item {item:?} due to {access:?} access for {tag:?}",
                                 )
                             }
                         },
-                    CreatedCallId(id) => format!("function call with id {id}"),
+                    CreatedCallId(id) =>
+                        format!("function call with id {id}"),
                     CreatedAlloc(AllocId(id), size, align, kind) =>
-                        format!("created {kind} allocation of {} bytes (alignment {} bytes) with id {id}", size.bytes(), align.bytes()),
-                    FreedAlloc(AllocId(id)) => format!("freed allocation with id {id}"),
+                        format!(
+                            "created {kind} allocation of {size} bytes (alignment {align} bytes) with id {id}",
+                            size = size.bytes(),
+                            align = align.bytes(),
+                        ),
+                    FreedAlloc(AllocId(id)) =>
+                        format!("freed allocation with id {id}"),
                     RejectedIsolatedOp(ref op) =>
                         format!("{op} was made to return an error due to isolation"),
                     ProgressReport =>
                         format!("progress report: current operation being executed is here"),
-                    Int2Ptr { .. } => format!("integer-to-pointer cast"),
+                    Int2Ptr { .. } =>
+                        format!("integer-to-pointer cast"),
                 };
 
                 let (title, diag_level) = match e {

src/helpers.rs

@@ -905,15 +905,6 @@ pub fn get_local_crates(tcx: TyCtxt<'_>) -> Vec<CrateNum> {
     local_crates
 }
 
-/// Formats an AllocRange like [0x1..0x3], for use in diagnostics.
-pub struct HexRange(pub AllocRange);
-
-impl std::fmt::Display for HexRange {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "[{:#x}..{:#x}]", self.0.start.bytes(), self.0.end().bytes())
-    }
-}
-
 /// Helper function used inside the shims of foreign functions to check that
 /// `target_os` is a supported UNIX OS.
 pub fn target_os_is_unix(target_os: &str) -> bool {

src/stacked_borrows/diagnostics.rs

@@ -4,7 +4,7 @@ use rustc_middle::mir::interpret::{AllocId, AllocRange};
 use rustc_span::{Span, SpanData};
 use rustc_target::abi::Size;
 
-use crate::helpers::{CurrentSpan, HexRange};
+use crate::helpers::CurrentSpan;
 use crate::stacked_borrows::{err_sb_ub, AccessKind, Permission};
 use crate::Item;
 use crate::SbTag;
@@ -178,7 +178,7 @@ fn operation_summary(
     alloc_id: AllocId,
     alloc_range: AllocRange,
 ) -> String {
-    format!("this error occurs as part of {} at {:?}{}", operation, alloc_id, HexRange(alloc_range))
+    format!("this error occurs as part of {operation} at {alloc_id:?}{alloc_range:?}")
 }
 
 fn error_cause(stack: &Stack, tag: SbTagExtra) -> &'static str {