Merge subtree update for toolchain nightly-2025-05-20 (model-checking#361)

This is an automated PR to merge library subtree updates from 2025-05-06
(rust-lang/rust@2e6882a) to 2025-05-20
(rust-lang/rust@60dabef) (inclusive)
into main. `git merge` resulted in conflicts, which require manual
resolution. Files were commited with merge conflict markers. **Do not
remove or edit the following annotations:**
git-subtree-dir: library
git-subtree-split: cc38593

---------

Signed-off-by: Jiahao XU <[email protected]>
Signed-off-by: Ayush Singh <[email protected]>
Signed-off-by: Sean Cross <[email protected]>
Signed-off-by: Vladimir Krivopalov <[email protected]>
Signed-off-by: xizheyin <[email protected]>
Co-authored-by: Thalia Archibald <[email protected]>
Co-authored-by: Chris Denton <[email protected]>
Co-authored-by: The Miri Cronjob Bot <[email protected]>
Co-authored-by: Gabriel Bjørnager Jensen <[email protected]>
Co-authored-by: Artur Roos <[email protected]>
Co-authored-by: Ralf Jung <[email protected]>
Co-authored-by: Jiahao XU <[email protected]>
Co-authored-by: bors <[email protected]>
Co-authored-by: 王宇逸 <[email protected]>
Co-authored-by: Nicholas Nethercote <[email protected]>
Co-authored-by: Hegui Dai <[email protected]>
Co-authored-by: Urgau <[email protected]>
Co-authored-by: Matthias Krüger <[email protected]>
Co-authored-by: bendn <[email protected]>
Co-authored-by: Trevor Gross <[email protected]>
Co-authored-by: ismailarilik <[email protected]>
Co-authored-by: Tobias <[email protected]>
Co-authored-by: Ethan Wu <[email protected]>
Co-authored-by: Ayush Singh <[email protected]>
Co-authored-by: Jake Goulding <[email protected]>
Co-authored-by: Michael Howell <[email protected]>
Co-authored-by: Christopher Durham <[email protected]>
Co-authored-by: Pavel Grigorenko <[email protected]>
Co-authored-by: LemonJ <[email protected]>
Co-authored-by: SabrinaJewson <[email protected]>
Co-authored-by: joboet <[email protected]>
Co-authored-by: Andrew Zhogin <[email protected]>
Co-authored-by: DaniPopes <[email protected]>
Co-authored-by: Lieselotte <[email protected]>
Co-authored-by: Sean Cross <[email protected]>
Co-authored-by: Trevor Gross <[email protected]>
Co-authored-by: Jon Bauman <[email protected]>
Co-authored-by: binarycat <[email protected]>
Co-authored-by: Mara Bos <[email protected]>
Co-authored-by: Mathis B <[email protected]>
Co-authored-by: Zachary S <[email protected]>
Co-authored-by: Amanieu d'Antras <[email protected]>
Co-authored-by: sayantn <[email protected]>
Co-authored-by: Eyal Kalderon <[email protected]>
Co-authored-by: Guillaume Gomez <[email protected]>
Co-authored-by: Lynnesbian <[email protected]>
Co-authored-by: Christopher Berner <[email protected]>
Co-authored-by: Stuart Cook <[email protected]>
Co-authored-by: Paolo Barbolini <[email protected]>
Co-authored-by: github-actions <[email protected]>
Co-authored-by: The 8472 <[email protected]>
Co-authored-by: Nick Kocharhook <[email protected]>
Co-authored-by: Vladimir Krivopalov <[email protected]>
Co-authored-by: Vilim Lendvaj <[email protected]>
Co-authored-by: David Tolnay <[email protected]>
Co-authored-by: Marijn Schouten <[email protected]>
Co-authored-by: Jacob Pratt <[email protected]>
Co-authored-by: ivmarkov <[email protected]>
Co-authored-by: Martin Kröning <[email protected]>
Co-authored-by: Daniel Paoliello <[email protected]>
Co-authored-by: Luca Versari <[email protected]>
Co-authored-by: xizheyin <[email protected]>
Co-authored-by: Ben Kimock <[email protected]>
Co-authored-by: Dietrich Daroch <[email protected]>
Co-authored-by: León Orell Valerian Liehr <[email protected]>
Co-authored-by: Pietro Albini <[email protected]>
Co-authored-by: Julian Knodt <[email protected]>
Co-authored-by: Michael Goulet <[email protected]>
Co-authored-by: Michał Łowicki <[email protected]>
Co-authored-by: Samuel Tardieu <[email protected]>
Co-authored-by: B I Mohammed Abbas <[email protected]>
Co-authored-by: Federico Terzi <[email protected]>
Co-authored-by: sam skeoch <[email protected]>
Co-authored-by: est31 <[email protected]>
Co-authored-by: Speedy_Lex <[email protected]>
Co-authored-by: Mario Pastorelli <[email protected]>
Co-authored-by: gitbot <git@bot>
Co-authored-by: Michael Tautschnig <[email protected]>

Author: 73 people

library/Cargo.lock

@@ -17,7 +17,7 @@ bench = false
 [dependencies]
 core = { path = "../core", public = true }
 safety = { path = "../contracts/safety" }
-compiler_builtins = { version = "=0.1.156", features = ['rustc-dep-of-std'] }
+compiler_builtins = { version = "=0.1.159", features = ['rustc-dep-of-std'] }
 
 [features]
 compiler-builtins-mem = ['compiler_builtins/mem']

library/alloc/Cargo.toml

@@ -1917,14 +1917,13 @@ pub struct ExtractIf<
     V,
     F,
     #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator + Clone = Global,
-> where
-    F: 'a + FnMut(&K, &mut V) -> bool,
-{
+> {
     pred: F,
     inner: ExtractIfInner<'a, K, V>,
     /// The BTreeMap will outlive this IntoIter so we don't care about drop order for `alloc`.
     alloc: A,
 }
+
 /// Most of the implementation of ExtractIf are generic over the type
 /// of the predicate, thus also serving for BTreeSet::ExtractIf.
 pub(super) struct ExtractIfInner<'a, K, V> {
@@ -1940,14 +1939,14 @@ pub(super) struct ExtractIfInner<'a, K, V> {
 }
 
 #[unstable(feature = "btree_extract_if", issue = "70530")]
-impl<K, V, F> fmt::Debug for ExtractIf<'_, K, V, F>
+impl<K, V, F, A> fmt::Debug for ExtractIf<'_, K, V, F, A>
 where
     K: fmt::Debug,
     V: fmt::Debug,
-    F: FnMut(&K, &mut V) -> bool,
+    A: Allocator + Clone,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_tuple("ExtractIf").field(&self.inner.peek()).finish()
+        f.debug_struct("ExtractIf").field("peek", &self.inner.peek()).finish_non_exhaustive()
     }
 }
 

library/alloc/src/collections/btree/map.rs

@@ -1556,24 +1556,23 @@ pub struct ExtractIf<
     T,
     F,
     #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator + Clone = Global,
-> where
-    T: 'a,
-    F: 'a + FnMut(&T) -> bool,
-{
+> {
     pred: F,
     inner: super::map::ExtractIfInner<'a, T, SetValZST>,
     /// The BTreeMap will outlive this IntoIter so we don't care about drop order for `alloc`.
     alloc: A,
 }
 
 #[unstable(feature = "btree_extract_if", issue = "70530")]
-impl<T, F, A: Allocator + Clone> fmt::Debug for ExtractIf<'_, T, F, A>
+impl<T, F, A> fmt::Debug for ExtractIf<'_, T, F, A>
 where
     T: fmt::Debug,
-    F: FnMut(&T) -> bool,
+    A: Allocator + Clone,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_tuple("ExtractIf").field(&self.inner.peek().map(|(k, _)| k)).finish()
+        f.debug_struct("ExtractIf")
+            .field("peek", &self.inner.peek().map(|(k, _)| k))
+            .finish_non_exhaustive()
     }
 }
 

library/alloc/src/collections/btree/set.rs

@@ -1976,9 +1976,14 @@ where
 }
 
 #[stable(feature = "extract_if", since = "1.87.0")]
-impl<T: fmt::Debug, F> fmt::Debug for ExtractIf<'_, T, F> {
+impl<T, F, A> fmt::Debug for ExtractIf<'_, T, F, A>
+where
+    T: fmt::Debug,
+    A: Allocator,
+{
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_tuple("ExtractIf").field(&self.list).finish()
+        let peek = self.it.map(|node| unsafe { &node.as_ref().element });
+        f.debug_struct("ExtractIf").field("peek", &peek).finish_non_exhaustive()
     }
 }
 

library/alloc/src/collections/linked_list.rs

@@ -1191,6 +1191,73 @@ impl<T, A: Allocator> VecDeque<T, A> {
         }
     }
 
+    /// Shortens the deque, keeping the last `len` elements and dropping
+    /// the rest.
+    ///
+    /// If `len` is greater or equal to the deque's current length, this has
+    /// no effect.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #![feature(vec_deque_truncate_front)]
+    /// use std::collections::VecDeque;
+    ///
+    /// let mut buf = VecDeque::new();
+    /// buf.push_front(5);
+    /// buf.push_front(10);
+    /// buf.push_front(15);
+    /// assert_eq!(buf, [15, 10, 5]);
+    /// assert_eq!(buf.as_slices(), (&[15, 10, 5][..], &[][..]));
+    /// buf.truncate_front(1);
+    /// assert_eq!(buf.as_slices(), (&[5][..], &[][..]));
+    /// ```
+    #[unstable(feature = "vec_deque_truncate_front", issue = "140667")]
+    pub fn truncate_front(&mut self, len: usize) {
+        /// Runs the destructor for all items in the slice when it gets dropped (normally or
+        /// during unwinding).
+        struct Dropper<'a, T>(&'a mut [T]);
+
+        impl<'a, T> Drop for Dropper<'a, T> {
+            fn drop(&mut self) {
+                unsafe {
+                    ptr::drop_in_place(self.0);
+                }
+            }
+        }
+
+        unsafe {
+            if len >= self.len {
+                // No action is taken
+                return;
+            }
+
+            let (front, back) = self.as_mut_slices();
+            if len > back.len() {
+                // The 'back' slice remains unchanged.
+                // front.len() + back.len() == self.len, so 'end' is non-negative
+                // and end < front.len()
+                let end = front.len() - (len - back.len());
+                let drop_front = front.get_unchecked_mut(..end) as *mut _;
+                self.head += end;
+                self.len = len;
+                ptr::drop_in_place(drop_front);
+            } else {
+                let drop_front = front as *mut _;
+                // 'end' is non-negative by the condition above
+                let end = back.len() - len;
+                let drop_back = back.get_unchecked_mut(..end) as *mut _;
+                self.head = self.to_physical_idx(self.len - len);
+                self.len = len;
+
+                // Make sure the second half is dropped even when a destructor
+                // in the first one panics.
+                let _back_dropper = Dropper(&mut *drop_back);
+                ptr::drop_in_place(drop_front);
+            }
+        }
+    }
+
     /// Returns a reference to the underlying allocator.
     #[unstable(feature = "allocator_api", issue = "32838")]
     #[inline]

library/alloc/src/collections/vec_deque/mod.rs

@@ -87,5 +87,5 @@ pub use self::c_str::CString;
 #[stable(feature = "alloc_c_string", since = "1.64.0")]
 pub use self::c_str::{FromVecWithNulError, IntoStringError, NulError};
 
-#[stable(feature = "c_str_module", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "c_str_module", since = "1.88.0")]
 pub mod c_str;

library/alloc/src/ffi/mod.rs

@@ -287,7 +287,7 @@ impl<T, A: Allocator> RawVec<T, A> {
     }
 
     #[inline]
-    pub(crate) fn non_null(&self) -> NonNull<T> {
+    pub(crate) const fn non_null(&self) -> NonNull<T> {
         self.inner.non_null()
     }
 

library/alloc/src/raw_vec/mod.rs

@@ -3536,11 +3536,11 @@ impl<T> Default for Weak<T> {
     }
 }
 
-// NOTE: We checked_add here to deal with mem::forget safely. In particular
-// if you mem::forget Rcs (or Weaks), the ref-count can overflow, and then
-// you can free the allocation while outstanding Rcs (or Weaks) exist.
-// We abort because this is such a degenerate scenario that we don't care about
-// what happens -- no real program should ever experience this.
+// NOTE: If you mem::forget Rcs (or Weaks), drop is skipped and the ref-count
+// is not decremented, meaning the ref-count can overflow, and then you can
+// free the allocation while outstanding Rcs (or Weaks) exist, which would be
+// unsound. We abort because this is such a degenerate scenario that we don't
+// care about what happens -- no real program should ever experience this.
 //
 // This should have negligible overhead since you don't actually need to
 // clone these much in Rust thanks to ownership and move-semantics.