btj
diff --git a/‎library/Cargo.lock‎
Lines changed: 8 additions & 72 deletions b/‎library/Cargo.lock‎
Lines changed: 8 additions & 72 deletions
diff --git a/‎library/alloc/Cargo.toml‎
Lines changed: 1 addition & 1 deletion b/‎library/alloc/Cargo.toml‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎library/alloc/src/collections/btree/map.rs‎
Lines changed: 5 additions & 6 deletions b/‎library/alloc/src/collections/btree/map.rs‎
Lines changed: 5 additions & 6 deletions
diff --git a/‎library/alloc/src/collections/btree/set.rs‎
Lines changed: 6 additions & 7 deletions b/‎library/alloc/src/collections/btree/set.rs‎
Lines changed: 6 additions & 7 deletions
diff --git a/‎library/alloc/src/collections/linked_list.rs‎
Lines changed: 7 additions & 2 deletions b/‎library/alloc/src/collections/linked_list.rs‎
Lines changed: 7 additions & 2 deletions
diff --git a/‎library/alloc/src/collections/vec_deque/mod.rs‎
Lines changed: 67 additions & 0 deletions b/‎library/alloc/src/collections/vec_deque/mod.rs‎
Lines changed: 67 additions & 0 deletions
diff --git a/‎library/alloc/src/ffi/mod.rs‎
Lines changed: 1 addition & 1 deletion b/‎library/alloc/src/ffi/mod.rs‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎library/alloc/src/raw_vec/mod.rs‎
Lines changed: 1 addition & 1 deletion b/‎library/alloc/src/raw_vec/mod.rs‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎library/alloc/src/rc.rs‎
Lines changed: 5 additions & 5 deletions b/‎library/alloc/src/rc.rs‎
Lines changed: 5 additions & 5 deletions
@@ -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']
 
@@ -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()
     }
 }
 
 
@@ -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()
     }
 }
 
 
@@ -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()
     }
 }
 
 
@@ -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]
 
@@ -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;
@@ -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()
     }
 
 
@@ -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.
Original file line number	Diff line number	Diff line change
`@@ -1976,9 +1976,14 @@ where`
`1976`	`1976`	`}`
`1977`	`1977`
`1978`	`1978`	`#[stable(feature = "extract_if", since = "1.87.0")]`
`1979`		`-impl<T: fmt::Debug, F> fmt::Debug for ExtractIf<'_, T, F> {`
	`1979`	`+impl<T, F, A> fmt::Debug for ExtractIf<'_, T, F, A>`
	`1980`	`+where`
	`1981`	`+ T: fmt::Debug,`
	`1982`	`+ A: Allocator,`
	`1983`	`+{`
`1980`	`1984`	`fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {`
`1981`		`- f.debug_tuple("ExtractIf").field(&self.list).finish()`
	`1985`	`+ let peek = self.it.map(\|node\| unsafe { &node.as_ref().element });`
	`1986`	`+ f.debug_struct("ExtractIf").field("peek", &peek).finish_non_exhaustive()`
`1982`	`1987`	`}`
`1983`	`1988`	`}`
`1984`	`1989`
Original file line number	Diff line number	Diff line change
`@@ -287,7 +287,7 @@ impl<T, A: Allocator> RawVec<T, A> {`
`287`	`287`	`}`
`288`	`288`
`289`	`289`	`#[inline]`
`290`		`- pub(crate) fn non_null(&self) -> NonNull<T> {`
	`290`	`+ pub(crate) const fn non_null(&self) -> NonNull<T> {`
`291`	`291`	`self.inner.non_null()`
`292`	`292`	`}`
`293`	`293`