Merge branch 'main' into btree-node

library/alloc/Cargo.toml

@@ -20,6 +20,10 @@ rand_xorshift = "0.3.0"
 name = "alloctests"
 path = "tests/lib.rs"
 
+[[test]]
+name = "vec_deque_alloc_error"
+path = "tests/vec_deque_alloc_error.rs"
+
 [[bench]]
 name = "allocbenches"
 path = "benches/lib.rs"
@@ -43,9 +47,6 @@ optimize_for_size = ["core/optimize_for_size"]
 
 [lints.rust.unexpected_cfgs]
 level = "warn"
-# x.py uses beta cargo, so `check-cfg` entries do not yet take effect
-# for rust-lang/rust. But for users of `-Zbuild-std` it does.
-# The unused warning is waiting for rust-lang/cargo#13925 to reach beta.
 check-cfg = [
  'cfg(bootstrap)',
  'cfg(no_global_oom_handling)',

library/alloc/src/alloc.rs

@@ -424,29 +424,3 @@ pub mod __alloc_error_handler {
  }
  }
 }
-
-#[cfg(not(no_global_oom_handling))]
-/// Specialize clones into pre-allocated, uninitialized memory.
-/// Used by `Box::clone` and `Rc`/`Arc::make_mut`.
-pub(crate) trait WriteCloneIntoRaw: Sized {
- unsafe fn write_clone_into_raw(&self, target: *mut Self);
-}
-
-#[cfg(not(no_global_oom_handling))]
-impl<T: Clone> WriteCloneIntoRaw for T {
- #[inline]
- default unsafe fn write_clone_into_raw(&self, target: *mut Self) {
- // Having allocated *first* may allow the optimizer to create
- // the cloned value in-place, skipping the local and move.
- unsafe { target.write(self.clone()) };
- }
-}
-
-#[cfg(not(no_global_oom_handling))]
-impl<T: Copy> WriteCloneIntoRaw for T {
- #[inline]
- unsafe fn write_clone_into_raw(&self, target: *mut Self) {
- // We can always copy in-place, without ever involving a local value.
- unsafe { target.copy_from_nonoverlapping(self, 1) };
- }
-}

library/alloc/src/boxed.rs

@@ -145,8 +145,7 @@
 //! to `into_iter()` for boxed slices will defer to the slice implementation on editions before
 //! 2024:
 //!
-#![cfg_attr(bootstrap, doc = "```rust,edition2021,ignore")]
-#![cfg_attr(not(bootstrap), doc = "```rust,edition2021")]
+//! ```rust,edition2021
 //! // Rust 2015, 2018, and 2021:
 //!
 //! # #![allow(boxed_slice_into_iter)] // override our `deny(warnings)`
@@ -189,6 +188,8 @@
 use core::any::Any;
 use core::async_iter::AsyncIterator;
 use core::borrow;
+#[cfg(not(no_global_oom_handling))]
+use core::clone::CloneToUninit;
 use core::cmp::Ordering;
 use core::error::Error;
 use core::fmt;
@@ -208,7 +209,7 @@ use core::slice;
 use core::task::{Context, Poll};
 
 #[cfg(not(no_global_oom_handling))]
-use crate::alloc::{handle_alloc_error, WriteCloneIntoRaw};
+use crate::alloc::handle_alloc_error;
 use crate::alloc::{AllocError, Allocator, Global, Layout};
 #[cfg(not(no_global_oom_handling))]
 use crate::borrow::Cow;
@@ -1212,6 +1213,9 @@ impl<T: ?Sized, A: Allocator> Box<T, A> {
  /// let static_ref: &'static mut usize = Box::leak(x);
  /// *static_ref += 1;
  /// assert_eq!(*static_ref, 42);
+ /// # // FIXME(https://github.com/rust-lang/miri/issues/3670):
+ /// # // use -Zmiri-disable-leak-check instead of unleaking in tests meant to leak.
+ /// # drop(unsafe { Box::from_raw(static_ref) });
  /// ```
  ///
  /// Unsized data:
@@ -1221,6 +1225,9 @@ impl<T: ?Sized, A: Allocator> Box<T, A> {
  /// let static_ref = Box::leak(x);
  /// static_ref[0] = 4;
  /// assert_eq!(*static_ref, [4, 2, 3]);
+ /// # // FIXME(https://github.com/rust-lang/miri/issues/3670):
+ /// # // use -Zmiri-disable-leak-check instead of unleaking in tests meant to leak.
+ /// # drop(unsafe { Box::from_raw(static_ref) });
  /// ```
  #[stable(feature = "box_leak", since = "1.26.0")]
  #[inline]
@@ -1347,7 +1354,7 @@ impl<T: Clone, A: Allocator + Clone> Clone for Box<T, A> {
  // Pre-allocate memory to allow writing the cloned value directly.
  let mut boxed = Self::new_uninit_in(self.1.clone());
  unsafe {
- (**self).write_clone_into_raw(boxed.as_mut_ptr());
+ (**self).clone_to_uninit(boxed.as_mut_ptr());
  boxed.assume_init()
  }
  }
@@ -2123,23 +2130,23 @@ impl<I> FromIterator<I> for Box<[I]> {
 
 /// This implementation is required to make sure that the `Box<[I]>: IntoIterator`
 /// implementation doesn't overlap with `IntoIterator for T where T: Iterator` blanket.
-#[stable(feature = "boxed_slice_into_iter", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "boxed_slice_into_iter", since = "1.80.0")]
 impl<I, A: Allocator> !Iterator for Box<[I], A> {}
 
 /// This implementation is required to make sure that the `&Box<[I]>: IntoIterator`
 /// implementation doesn't overlap with `IntoIterator for T where T: Iterator` blanket.
-#[stable(feature = "boxed_slice_into_iter", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "boxed_slice_into_iter", since = "1.80.0")]
 impl<'a, I, A: Allocator> !Iterator for &'a Box<[I], A> {}
 
 /// This implementation is required to make sure that the `&mut Box<[I]>: IntoIterator`
 /// implementation doesn't overlap with `IntoIterator for T where T: Iterator` blanket.
-#[stable(feature = "boxed_slice_into_iter", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "boxed_slice_into_iter", since = "1.80.0")]
 impl<'a, I, A: Allocator> !Iterator for &'a mut Box<[I], A> {}
 
 // Note: the `#[rustc_skip_during_method_dispatch(boxed_slice)]` on `trait IntoIterator`
 // hides this implementation from explicit `.into_iter()` calls on editions < 2024,
 // so those calls will still resolve to the slice implementation, by reference.
-#[stable(feature = "boxed_slice_into_iter", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "boxed_slice_into_iter", since = "1.80.0")]
 impl<I, A: Allocator> IntoIterator for Box<[I], A> {
  type IntoIter = vec::IntoIter<I, A>;
  type Item = I;
@@ -2148,7 +2155,7 @@ impl<I, A: Allocator> IntoIterator for Box<[I], A> {
  }
 }
 
-#[stable(feature = "boxed_slice_into_iter", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "boxed_slice_into_iter", since = "1.80.0")]
 impl<'a, I, A: Allocator> IntoIterator for &'a Box<[I], A> {
  type IntoIter = slice::Iter<'a, I>;
  type Item = &'a I;
@@ -2157,7 +2164,7 @@ impl<'a, I, A: Allocator> IntoIterator for &'a Box<[I], A> {
  }
 }
 
-#[stable(feature = "boxed_slice_into_iter", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "boxed_slice_into_iter", since = "1.80.0")]
 impl<'a, I, A: Allocator> IntoIterator for &'a mut Box<[I], A> {
  type IntoIter = slice::IterMut<'a, I>;
  type Item = &'a mut I;
@@ -2167,47 +2174,47 @@ impl<'a, I, A: Allocator> IntoIterator for &'a mut Box<[I], A> {
 }
 
 #[cfg(not(no_global_oom_handling))]
-#[stable(feature = "boxed_str_from_iter", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "boxed_str_from_iter", since = "1.80.0")]
 impl FromIterator<char> for Box<str> {
  fn from_iter<T: IntoIterator<Item = char>>(iter: T) -> Self {
  String::from_iter(iter).into_boxed_str()
  }
 }
 
 #[cfg(not(no_global_oom_handling))]
-#[stable(feature = "boxed_str_from_iter", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "boxed_str_from_iter", since = "1.80.0")]
 impl<'a> FromIterator<&'a char> for Box<str> {
  fn from_iter<T: IntoIterator<Item = &'a char>>(iter: T) -> Self {
  String::from_iter(iter).into_boxed_str()
  }
 }
 
 #[cfg(not(no_global_oom_handling))]
-#[stable(feature = "boxed_str_from_iter", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "boxed_str_from_iter", since = "1.80.0")]
 impl<'a> FromIterator<&'a str> for Box<str> {
  fn from_iter<T: IntoIterator<Item = &'a str>>(iter: T) -> Self {
  String::from_iter(iter).into_boxed_str()
  }
 }
 
 #[cfg(not(no_global_oom_handling))]
-#[stable(feature = "boxed_str_from_iter", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "boxed_str_from_iter", since = "1.80.0")]
 impl FromIterator<String> for Box<str> {
  fn from_iter<T: IntoIterator<Item = String>>(iter: T) -> Self {
  String::from_iter(iter).into_boxed_str()
  }
 }
 
 #[cfg(not(no_global_oom_handling))]
-#[stable(feature = "boxed_str_from_iter", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "boxed_str_from_iter", since = "1.80.0")]
 impl<A: Allocator> FromIterator<Box<str, A>> for Box<str> {
  fn from_iter<T: IntoIterator<Item = Box<str, A>>>(iter: T) -> Self {
  String::from_iter(iter).into_boxed_str()
  }
 }
 
 #[cfg(not(no_global_oom_handling))]
-#[stable(feature = "boxed_str_from_iter", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "boxed_str_from_iter", since = "1.80.0")]
 impl<'a> FromIterator<Cow<'a, str>> for Box<str> {
  fn from_iter<T: IntoIterator<Item = Cow<'a, str>>>(iter: T) -> Self {
  String::from_iter(iter).into_boxed_str()
@@ -2373,7 +2380,7 @@ impl dyn Error + Send {
  let err: Box<dyn Error> = self;
  <dyn Error>::downcast(err).map_err(|s| unsafe {
  // Reapply the `Send` marker.
- Box::from_raw(Box::into_raw(s) as *mut (dyn Error + Send))
+ mem::transmute::<Box<dyn Error>, Box<dyn Error + Send>>(s)
  })
  }
 }
@@ -2386,8 +2393,8 @@ impl dyn Error + Send + Sync {
  pub fn downcast<T: Error + 'static>(self: Box<Self>) -> Result<Box<T>, Box<Self>> {
  let err: Box<dyn Error> = self;
  <dyn Error>::downcast(err).map_err(|s| unsafe {
- // Reapply the `Send + Sync` marker.
- Box::from_raw(Box::into_raw(s) as *mut (dyn Error + Send + Sync))
+ // Reapply the `Send + Sync` markers.
+ mem::transmute::<Box<dyn Error>, Box<dyn Error + Send + Sync>>(s)
  })
  }
 }

library/alloc/src/boxed/thin.rs

@@ -1,6 +1,7 @@
-// Based on
-// https://github.com/matthieu-m/rfc2580/blob/b58d1d3cba0d4b5e859d3617ea2d0943aaa31329/examples/thin.rs
-// by matthieu-m
+//! Based on
+//! <https://github.com/matthieu-m/rfc2580/blob/b58d1d3cba0d4b5e859d3617ea2d0943aaa31329/examples/thin.rs>
+//! by matthieu-m
+
 use crate::alloc::{self, Layout, LayoutError};
 use core::error::Error;
 use core::fmt::{self, Debug, Display, Formatter};

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

@@ -440,7 +440,7 @@ impl<T: Ord> BinaryHeap<T> {
  /// heap.push(4);
  /// ```
  #[stable(feature = "rust1", since = "1.0.0")]
- #[rustc_const_unstable(feature = "const_binary_heap_constructor", issue = "112353")]
+ #[rustc_const_stable(feature = "const_binary_heap_constructor", since = "1.80.0")]
  #[must_use]
  pub const fn new() -> BinaryHeap<T> {
  BinaryHeap { data: vec![] }
@@ -484,7 +484,7 @@ impl<T: Ord, A: Allocator> BinaryHeap<T, A> {
  /// heap.push(4);
  /// ```
  #[unstable(feature = "allocator_api", issue = "32838")]
- #[rustc_const_unstable(feature = "const_binary_heap_constructor", issue = "112353")]
+ #[rustc_const_unstable(feature = "const_binary_heap_new_in", issue = "112353")]
  #[must_use]
  pub const fn new_in(alloc: A) -> BinaryHeap<T, A> {
  BinaryHeap { data: Vec::new_in(alloc) }
@@ -1213,7 +1213,6 @@ impl<T, A: Allocator> BinaryHeap<T, A> {
  /// Basic usage:
  ///
  /// ```
- /// #![feature(binary_heap_as_slice)]
  /// use std::collections::BinaryHeap;
  /// use std::io::{self, Write};
  ///
@@ -1222,7 +1221,7 @@ impl<T, A: Allocator> BinaryHeap<T, A> {
  /// io::sink().write(heap.as_slice()).unwrap();
  /// ```
  #[must_use]
- #[unstable(feature = "binary_heap_as_slice", issue = "83659")]
+ #[stable(feature = "binary_heap_as_slice", since = "1.80.0")]
  pub fn as_slice(&self) -> &[T] {
  self.data.as_slice()
  }

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

@@ -1796,18 +1796,18 @@ fn test_ord_absence() {
  }
 
  fn map_debug<K: Debug>(mut map: BTreeMap<K, ()>) {
- format!("{map:?}");
- format!("{:?}", map.iter());
- format!("{:?}", map.iter_mut());
- format!("{:?}", map.keys());
- format!("{:?}", map.values());
- format!("{:?}", map.values_mut());
+ let _ = format!("{map:?}");
+ let _ = format!("{:?}", map.iter());
+ let _ = format!("{:?}", map.iter_mut());
+ let _ = format!("{:?}", map.keys());
+ let _ = format!("{:?}", map.values());
+ let _ = format!("{:?}", map.values_mut());
  if true {
- format!("{:?}", map.into_iter());
+ let _ = format!("{:?}", map.into_iter());
  } else if true {
- format!("{:?}", map.into_keys());
+ let _ = format!("{:?}", map.into_keys());
  } else {
- format!("{:?}", map.into_values());
+ let _ = format!("{:?}", map.into_values());
  }
  }
 

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

@@ -705,9 +705,9 @@ fn test_ord_absence() {
  }
 
  fn set_debug<K: Debug>(set: BTreeSet<K>) {
- format!("{set:?}");
- format!("{:?}", set.iter());
- format!("{:?}", set.into_iter());
+ let _ = format!("{set:?}");
+ let _ = format!("{:?}", set.iter());
+ let _ = format!("{:?}", set.into_iter());
  }
 
  fn set_clone<K: Clone>(mut set: BTreeSet<K>) {

library/alloc/src/collections/linked_list.rs

@@ -1495,6 +1495,14 @@ impl<'a, T, A: Allocator> Cursor<'a, T, A> {
  pub fn back(&self) -> Option<&'a T> {
  self.list.back()
  }
+
+ /// Provides a reference to the cursor's parent list.
+ #[must_use]
+ #[inline(always)]
+ #[unstable(feature = "linked_list_cursors", issue = "58533")]
+ pub fn as_list(&self) -> &'a LinkedList<T, A> {
+ self.list
+ }
 }
 
 impl<'a, T, A: Allocator> CursorMut<'a, T, A> {
@@ -1605,6 +1613,18 @@ impl<'a, T, A: Allocator> CursorMut<'a, T, A> {
  pub fn as_cursor(&self) -> Cursor<'_, T, A> {
  Cursor { list: self.list, current: self.current, index: self.index }
  }
+
+ /// Provides a read-only reference to the cursor's parent list.
+ ///
+ /// The lifetime of the returned reference is bound to that of the
+ /// `CursorMut`, which means it cannot outlive the `CursorMut` and that the
+ /// `CursorMut` is frozen for the lifetime of the reference.
+ #[must_use]
+ #[inline(always)]
+ #[unstable(feature = "linked_list_cursors", issue = "58533")]
+ pub fn as_list(&self) -> &LinkedList<T, A> {
+ self.list
+ }
 }
 
 // Now the list editing operations
@@ -1705,7 +1725,7 @@ impl<'a, T, A: Allocator> CursorMut<'a, T, A> {
  unsafe {
  self.current = unlinked_node.as_ref().next;
  self.list.unlink_node(unlinked_node);
- let unlinked_node = Box::from_raw(unlinked_node.as_ptr());
+ let unlinked_node = Box::from_raw_in(unlinked_node.as_ptr(), &self.list.alloc);
  Some(unlinked_node.element)
  }
  }
@@ -1946,7 +1966,7 @@ where
  if (self.pred)(&mut node.as_mut().element) {
  // `unlink_node` is okay with aliasing `element` references.
  self.list.unlink_node(node);
- return Some(Box::from_raw(node.as_ptr()).element);
+ return Some(Box::from_raw_in(node.as_ptr(), &self.list.alloc).element);
  }
  }
  }