Use an explicit receiver in `DropGuard::dismiss`
diff --git a/library/core/src/mem/drop_guard.rs b/library/core/src/mem/drop_guard.rs
index 0131347..74bf353 100644
--- a/library/core/src/mem/drop_guard.rs
+++ b/library/core/src/mem/drop_guard.rs
@@ -79,30 +79,30 @@ pub const fn new(inner: T, f: F) -> Self {
///
/// let value = String::from("Nori likes chicken");
/// let guard = DropGuard::new(value, |s| println!("{s}"));
- /// assert_eq!(guard.dismiss(), "Nori likes chicken");
+ /// assert_eq!(DropGuard::dismiss(guard), "Nori likes chicken");
/// ```
#[unstable(feature = "drop_guard", issue = "144426")]
#[rustc_const_unstable(feature = "const_drop_guard", issue = "none")]
#[inline]
- pub const fn dismiss(self) -> T
+ pub const fn dismiss(guard: Self) -> T
where
F: [const] Destruct,
{
// First we ensure that dropping the guard will not trigger
// its destructor
- let mut this = ManuallyDrop::new(self);
+ let mut guard = ManuallyDrop::new(guard);
// Next we manually read the stored value from the guard.
//
// SAFETY: this is safe because we've taken ownership of the guard.
- let value = unsafe { ManuallyDrop::take(&mut this.inner) };
+ let value = unsafe { ManuallyDrop::take(&mut guard.inner) };
// Finally we drop the stored closure. We do this *after* having read
// the value, so that even if the closure's `drop` function panics,
// unwinding still tries to drop the value.
//
// SAFETY: this is safe because we've taken ownership of the guard.
- unsafe { ManuallyDrop::drop(&mut this.f) };
+ unsafe { ManuallyDrop::drop(&mut guard.f) };
value
}
}
diff --git a/library/coretests/tests/mem.rs b/library/coretests/tests/mem.rs
index 0058210..5247e01 100644
--- a/library/coretests/tests/mem.rs
+++ b/library/coretests/tests/mem.rs
@@ -815,7 +815,7 @@ fn drop_guard_into_inner() {
let dropped = Cell::new(false);
let value = DropGuard::new(42, |_| dropped.set(true));
let guard = DropGuard::new(value, |_| dropped.set(true));
- let inner = guard.dismiss();
+ let inner = DropGuard::dismiss(guard);
assert_eq!(dropped.get(), false);
assert_eq!(*inner, 42);
}
@@ -837,7 +837,7 @@ fn drop_guard_always_drops_value_if_closure_drop_unwinds() {
// run the destructor of the value we passed, which we validate.
let _ = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
let guard = DropGuard::new(value_with_tracked_destruction, closure_that_panics_on_drop);
- guard.dismiss();
+ DropGuard::dismiss(guard);
}));
assert!(value_was_dropped);
}
