rustup, fmt

Author: RalfJung

rust-version

@@ -1 +1 @@
-2019147c5642c08cdb9ad4cacd97dd1fa4ffa701
+acb8934fd57b3c2740c4abac0a5728c2c9b1423b

src/concurrency/sync.rs

@@ -322,10 +322,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
     /// otherwise returns the value from the closure
     fn rwlock_get_or_create<F>(&mut self, existing: F) -> InterpResult<'tcx, RwLockId>
     where
-        F: FnOnce(
-            &mut MiriInterpCx<'mir, 'tcx>,
-            RwLockId,
-        ) -> InterpResult<'tcx, Option<RwLockId>>,
+        F: FnOnce(&mut MiriInterpCx<'mir, 'tcx>, RwLockId) -> InterpResult<'tcx, Option<RwLockId>>,
     {
         let this = self.eval_context_mut();
         let next_index = this.machine.threads.sync.rwlocks.next_index();

src/concurrency/thread.rs

@@ -32,8 +32,9 @@ pub enum SchedulingAction {
 
 /// Timeout callbacks can be created by synchronization primitives to tell the
 /// scheduler that they should be called once some period of time passes.
-type TimeoutCallback<'mir, 'tcx> =
-    Box<dyn FnOnce(&mut InterpCx<'mir, 'tcx, MiriMachine<'mir, 'tcx>>) -> InterpResult<'tcx> + 'tcx>;
+type TimeoutCallback<'mir, 'tcx> = Box<
+    dyn FnOnce(&mut InterpCx<'mir, 'tcx, MiriMachine<'mir, 'tcx>>) -> InterpResult<'tcx> + 'tcx,
+>;
 
 /// A thread identifier.
 #[derive(Clone, Copy, Debug, PartialOrd, Ord, PartialEq, Eq, Hash)]

src/diagnostics.rs

@@ -109,7 +109,8 @@ fn prune_stacktrace<'tcx>(
             if has_local_frame {
                 // Remove all frames marked with `caller_location` -- that attribute indicates we
                 // usually want to point at the caller, not them.
-                stacktrace.retain(|frame| !frame.instance.def.requires_caller_location(machine.tcx));
+                stacktrace
+                    .retain(|frame| !frame.instance.def.requires_caller_location(machine.tcx));
 
                 // This is part of the logic that `std` uses to select the relevant part of a
                 // backtrace. But here, we only look for __rust_begin_short_backtrace, not
@@ -371,56 +372,48 @@ impl<'mir, 'tcx> MiriMachine<'mir, 'tcx> {
     pub fn emit_diagnostic(&self, e: NonHaltingDiagnostic) {
         use NonHaltingDiagnostic::*;
 
-        let stacktrace = MiriInterpCx::generate_stacktrace_from_stack(self.threads.active_thread_stack());
+        let stacktrace =
+            MiriInterpCx::generate_stacktrace_from_stack(self.threads.active_thread_stack());
         let (stacktrace, _was_pruned) = prune_stacktrace(stacktrace, self);
 
         let (title, diag_level) = match e {
-            RejectedIsolatedOp(_) =>
-                ("operation rejected by isolation", DiagLevel::Warning),
+            RejectedIsolatedOp(_) => ("operation rejected by isolation", DiagLevel::Warning),
             Int2Ptr { .. } => ("integer-to-pointer cast", DiagLevel::Warning),
             CreatedPointerTag(..)
             | PoppedPointerTag(..)
             | CreatedCallId(..)
             | CreatedAlloc(..)
             | FreedAlloc(..)
             | ProgressReport { .. }
-            | WeakMemoryOutdatedLoad =>
-                ("tracking was triggered", DiagLevel::Note),
+            | WeakMemoryOutdatedLoad => ("tracking was triggered", DiagLevel::Note),
         };
 
         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:?}{range:?}"),
             PoppedPointerTag(item, tag) =>
                 match tag {
-                    None =>
-                        format!(
-                            "popped tracked tag for item {item:?} due to deallocation",
-                        ),
+                    None => format!("popped tracked tag for item {item:?} due to deallocation",),
                     Some((tag, access)) => {
                         format!(
                             "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 {size} bytes (alignment {align} bytes) with id {id}",
                     size = size.bytes(),
                     align = align.bytes(),
                 ),
-            FreedAlloc(AllocId(id)) =>
-                format!("freed allocation with id {id}"),
+            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"),
             WeakMemoryOutdatedLoad =>
                 format!("weak memory emulation: outdated value returned from load"),
         };
@@ -429,22 +422,48 @@ impl<'mir, 'tcx> MiriMachine<'mir, 'tcx> {
             ProgressReport { block_count } => {
                 // It is important that each progress report is slightly different, since
                 // identical diagnostics are being deduplicated.
-                vec![
-                    (None, format!("so far, {block_count} basic blocks have been executed")),
-                ]
+                vec![(None, format!("so far, {block_count} basic blocks have been executed"))]
             }
             _ => vec![],
         };
 
         let helps = match e {
             Int2Ptr { details: true } =>
                 vec![
-                    (None, format!("This program is using integer-to-pointer casts or (equivalently) `ptr::from_exposed_addr`,")),
-                    (None, format!("which means that Miri might miss pointer bugs in this program.")),
-                    (None, format!("See https://doc.rust-lang.org/nightly/std/ptr/fn.from_exposed_addr.html for more details on that operation.")),
-                    (None, format!("To ensure that Miri does not miss bugs in your program, use Strict Provenance APIs (https://doc.rust-lang.org/nightly/std/ptr/index.html#strict-provenance, https://crates.io/crates/sptr) instead.")),
-                    (None, format!("You can then pass the `-Zmiri-strict-provenance` flag to Miri, to ensure you are not relying on `from_exposed_addr` semantics.")),
-                    (None, format!("Alternatively, the `-Zmiri-permissive-provenance` flag disables this warning.")),
+                    (
+                        None,
+                        format!(
+                            "This program is using integer-to-pointer casts or (equivalently) `ptr::from_exposed_addr`,"
+                        ),
+                    ),
+                    (
+                        None,
+                        format!("which means that Miri might miss pointer bugs in this program."),
+                    ),
+                    (
+                        None,
+                        format!(
+                            "See https://doc.rust-lang.org/nightly/std/ptr/fn.from_exposed_addr.html for more details on that operation."
+                        ),
+                    ),
+                    (
+                        None,
+                        format!(
+                            "To ensure that Miri does not miss bugs in your program, use Strict Provenance APIs (https://doc.rust-lang.org/nightly/std/ptr/index.html#strict-provenance, https://crates.io/crates/sptr) instead."
+                        ),
+                    ),
+                    (
+                        None,
+                        format!(
+                            "You can then pass the `-Zmiri-strict-provenance` flag to Miri, to ensure you are not relying on `from_exposed_addr` semantics."
+                        ),
+                    ),
+                    (
+                        None,
+                        format!(
+                            "Alternatively, the `-Zmiri-permissive-provenance` flag disables this warning."
+                        ),
+                    ),
                 ],
             _ => vec![],
         };

src/eval.rs

@@ -180,7 +180,8 @@ pub fn create_ecx<'mir, 'tcx: 'mir>(
     entry_id: DefId,
     entry_type: EntryFnType,
     config: &MiriConfig,
-) -> InterpResult<'tcx, (InterpCx<'mir, 'tcx, MiriMachine<'mir, 'tcx>>, MPlaceTy<'tcx, Provenance>)> {
+) -> InterpResult<'tcx, (InterpCx<'mir, 'tcx, MiriMachine<'mir, 'tcx>>, MPlaceTy<'tcx, Provenance>)>
+{
     let param_env = ty::ParamEnv::reveal_all();
     let layout_cx = LayoutCx { tcx, param_env };
     let mut ecx = InterpCx::new(

src/lib.rs

@@ -94,17 +94,17 @@ pub use crate::concurrency::{
     },
 };
 pub use crate::diagnostics::{
-    report_error, EvalContextExt as DiagnosticsEvalContextExt,
-    NonHaltingDiagnostic, TerminationInfo,
+    report_error, EvalContextExt as DiagnosticsEvalContextExt, NonHaltingDiagnostic,
+    TerminationInfo,
 };
 pub use crate::eval::{
     create_ecx, eval_entry, AlignmentCheck, BacktraceStyle, IsolatedOp, MiriConfig, RejectOpWith,
 };
 pub use crate::helpers::{CurrentSpan, EvalContextExt as HelpersEvalContextExt};
 pub use crate::intptrcast::ProvenanceMode;
 pub use crate::machine::{
-    AllocExtra, MiriMachine, FrameData, MiriInterpCx, MiriInterpCxExt, MiriMemoryKind,
-    Provenance, ProvenanceExtra, NUM_CPUS, PAGE_SIZE, STACK_ADDR, STACK_SIZE,
+    AllocExtra, FrameData, MiriInterpCx, MiriInterpCxExt, MiriMachine, MiriMemoryKind, Provenance,
+    ProvenanceExtra, NUM_CPUS, PAGE_SIZE, STACK_ADDR, STACK_SIZE,
 };
 pub use crate::mono_hash_map::MonoHashMap;
 pub use crate::operator::EvalContextExt as OperatorEvalContextExt;

src/stacked_borrows/diagnostics.rs

@@ -471,7 +471,9 @@ impl<'span, 'history, 'ecx, 'mir, 'tcx> DiagnosticCx<'span, 'history, 'ecx, 'mir
                 Some((orig_tag, kind))
             }
         };
-        self.current_span.machine().emit_diagnostic(NonHaltingDiagnostic::PoppedPointerTag(*item, summary));
+        self.current_span
+            .machine()
+            .emit_diagnostic(NonHaltingDiagnostic::PoppedPointerTag(*item, summary));
     }
 }
 

src/stacked_borrows/mod.rs

@@ -572,7 +572,8 @@ impl Stacks {
             // not through a pointer). That is, whenever we directly write to a local, this will pop
             // everything else off the stack, invalidating all previous pointers,
             // and in particular, *all* raw pointers.
-            MemoryKind::Stack => (extra.base_ptr_tag(id, current_span.machine()), Permission::Unique),
+            MemoryKind::Stack =>
+                (extra.base_ptr_tag(id, current_span.machine()), Permission::Unique),
             // Everything else is shared by default.
             _ => (extra.base_ptr_tag(id, current_span.machine()), Permission::SharedReadWrite),
         };