Merge subtree update for toolchain nightly-2025-10-09

.github/workflows/flux.yml

@@ -9,7 +9,7 @@ on:
 
 env:
  FIXPOINT_VERSION: "556104ba5508891c357b0bdf819ce706e93d9349"
- FLUX_VERSION: "f5e57bec353e2eb3550d2b7ba086462264dfa290"
+ FLUX_VERSION: "e01e0cd595af33b32faf6c96b032574478c29d5c"
 
 jobs:
  check-flux-on-core:

library/alloc/Cargo.toml

@@ -23,8 +23,6 @@ safety = { path = "../contracts/safety" }
 compiler-builtins-mem = ['compiler_builtins/mem']
 compiler-builtins-c = ["compiler_builtins/c"]
 compiler-builtins-no-f16-f128 = ["compiler_builtins/no-f16-f128"]
-# Make panics and failed asserts immediately abort without formatting any message
-panic_immediate_abort = ["core/panic_immediate_abort"]
 # Choose algorithms that are optimized for binary size instead of runtime performance
 optimize_for_size = ["core/optimize_for_size"]
 

library/alloc/src/alloc.rs

@@ -408,12 +408,12 @@ pub const fn handle_alloc_error(layout: Layout) -> ! {
  }
  }
 
- #[cfg(not(feature = "panic_immediate_abort"))]
+ #[cfg(not(panic = "immediate-abort"))]
  {
  core::intrinsics::const_eval_select((layout,), ct_error, rt_error)
  }
 
- #[cfg(feature = "panic_immediate_abort")]
+ #[cfg(panic = "immediate-abort")]
  ct_error(layout)
 }
 

library/alloc/src/boxed.rs

@@ -290,8 +290,6 @@ impl<T> Box<T> {
  /// # Examples
  ///
  /// ```
- /// #![feature(new_zeroed_alloc)]
- ///
  /// let zero = Box::<u32>::new_zeroed();
  /// let zero = unsafe { zero.assume_init() };
  ///
@@ -301,7 +299,7 @@ impl<T> Box<T> {
  /// [zeroed]: mem::MaybeUninit::zeroed
  #[cfg(not(no_global_oom_handling))]
  #[inline]
- #[unstable(feature = "new_zeroed_alloc", issue = "129396")]
+ #[stable(feature = "new_zeroed_alloc", since = "CURRENT_RUSTC_VERSION")]
  #[must_use]
  pub fn new_zeroed() -> Box<mem::MaybeUninit<T>> {
  Self::new_zeroed_in(Global)
@@ -358,7 +356,6 @@ impl<T> Box<T> {
  /// # Ok::<(), std::alloc::AllocError>(())
  /// ```
  #[unstable(feature = "allocator_api", issue = "32838")]
- // #[unstable(feature = "new_uninit", issue = "63291")]
  #[inline]
  pub fn try_new_uninit() -> Result<Box<mem::MaybeUninit<T>>, AllocError> {
  Box::try_new_uninit_in(Global)
@@ -384,7 +381,6 @@ impl<T> Box<T> {
  ///
  /// [zeroed]: mem::MaybeUninit::zeroed
  #[unstable(feature = "allocator_api", issue = "32838")]
- // #[unstable(feature = "new_uninit", issue = "63291")]
  #[inline]
  pub fn try_new_zeroed() -> Result<Box<mem::MaybeUninit<T>>, AllocError> {
  Box::try_new_zeroed_in(Global)
@@ -463,7 +459,6 @@ impl<T, A: Allocator> Box<T, A> {
  #[unstable(feature = "allocator_api", issue = "32838")]
  #[cfg(not(no_global_oom_handling))]
  #[must_use]
- // #[unstable(feature = "new_uninit", issue = "63291")]
  pub fn new_uninit_in(alloc: A) -> Box<mem::MaybeUninit<T>, A>
  where
  A: Allocator,
@@ -496,7 +491,6 @@ impl<T, A: Allocator> Box<T, A> {
  /// # Ok::<(), std::alloc::AllocError>(())
  /// ```
  #[unstable(feature = "allocator_api", issue = "32838")]
- // #[unstable(feature = "new_uninit", issue = "63291")]
  pub fn try_new_uninit_in(alloc: A) -> Result<Box<mem::MaybeUninit<T>, A>, AllocError>
  where
  A: Allocator,
@@ -532,7 +526,6 @@ impl<T, A: Allocator> Box<T, A> {
  /// [zeroed]: mem::MaybeUninit::zeroed
  #[unstable(feature = "allocator_api", issue = "32838")]
  #[cfg(not(no_global_oom_handling))]
- // #[unstable(feature = "new_uninit", issue = "63291")]
  #[must_use]
  pub fn new_zeroed_in(alloc: A) -> Box<mem::MaybeUninit<T>, A>
  where
@@ -570,7 +563,6 @@ impl<T, A: Allocator> Box<T, A> {
  ///
  /// [zeroed]: mem::MaybeUninit::zeroed
  #[unstable(feature = "allocator_api", issue = "32838")]
- // #[unstable(feature = "new_uninit", issue = "63291")]
  pub fn try_new_zeroed_in(alloc: A) -> Result<Box<mem::MaybeUninit<T>, A>, AllocError>
  where
  A: Allocator,
@@ -627,6 +619,37 @@ impl<T, A: Allocator> Box<T, A> {
  pub fn into_inner(boxed: Self) -> T {
  *boxed
  }
+
+ /// Consumes the `Box` without consuming its allocation, returning the wrapped value and a `Box`
+ /// to the uninitialized memory where the wrapped value used to live.
+ ///
+ /// This can be used together with [`write`](Box::write) to reuse the allocation for multiple
+ /// boxed values.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(box_take)]
+ ///
+ /// let c = Box::new(5);
+ ///
+ /// // take the value out of the box
+ /// let (value, uninit) = Box::take(c);
+ /// assert_eq!(value, 5);
+ ///
+ /// // reuse the box for a second value
+ /// let c = Box::write(uninit, 6);
+ /// assert_eq!(*c, 6);
+ /// ```
+ #[unstable(feature = "box_take", issue = "147212")]
+ pub fn take(boxed: Self) -> (T, Box<mem::MaybeUninit<T>, A>) {
+ unsafe {
+ let (raw, alloc) = Box::into_raw_with_allocator(boxed);
+ let value = raw.read();
+ let uninit = Box::from_raw_in(raw.cast::<mem::MaybeUninit<T>>(), alloc);
+ (value, uninit)
+ }
+ }
 }
 
 impl<T> Box<[T]> {
@@ -640,7 +663,7 @@ impl<T> Box<[T]> {
  /// values[0].write(1);
  /// values[1].write(2);
  /// values[2].write(3);
- /// let values = unsafe {values.assume_init() };
+ /// let values = unsafe { values.assume_init() };
  ///
  /// assert_eq!(*values, [1, 2, 3])
  /// ```
@@ -660,8 +683,6 @@ impl<T> Box<[T]> {
  /// # Examples
  ///
  /// ```
- /// #![feature(new_zeroed_alloc)]
- ///
  /// let values = Box::<[u32]>::new_zeroed_slice(3);
  /// let values = unsafe { values.assume_init() };
  ///
@@ -670,7 +691,7 @@ impl<T> Box<[T]> {
  ///
  /// [zeroed]: mem::MaybeUninit::zeroed
  #[cfg(not(no_global_oom_handling))]
- #[unstable(feature = "new_zeroed_alloc", issue = "129396")]
+ #[stable(feature = "new_zeroed_alloc", since = "CURRENT_RUSTC_VERSION")]
  #[must_use]
  pub fn new_zeroed_slice(len: usize) -> Box<[mem::MaybeUninit<T>]> {
  unsafe { RawVec::with_capacity_zeroed(len).into_box(len) }
@@ -785,7 +806,6 @@ impl<T, A: Allocator> Box<[T], A> {
  /// ```
  #[cfg(not(no_global_oom_handling))]
  #[unstable(feature = "allocator_api", issue = "32838")]
- // #[unstable(feature = "new_uninit", issue = "63291")]
  #[must_use]
  pub fn new_uninit_slice_in(len: usize, alloc: A) -> Box<[mem::MaybeUninit<T>], A> {
  unsafe { RawVec::with_capacity_in(len, alloc).into_box(len) }
@@ -813,7 +833,6 @@ impl<T, A: Allocator> Box<[T], A> {
  /// [zeroed]: mem::MaybeUninit::zeroed
  #[cfg(not(no_global_oom_handling))]
  #[unstable(feature = "allocator_api", issue = "32838")]
- // #[unstable(feature = "new_uninit", issue = "63291")]
  #[must_use]
  pub fn new_zeroed_slice_in(len: usize, alloc: A) -> Box<[mem::MaybeUninit<T>], A> {
  unsafe { RawVec::with_capacity_zeroed_in(len, alloc).into_box(len) }
@@ -1718,7 +1737,7 @@ impl Default for Box<str> {
 }
 
 #[cfg(not(no_global_oom_handling))]
-#[stable(feature = "pin_default_impls", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "pin_default_impls", since = "1.91.0")]
 impl<T> Default for Pin<Box<T>>
 where
  T: ?Sized,

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

@@ -194,6 +194,9 @@ pub struct BTreeMap<
  root: Option<Root<K, V>>,
  length: usize,
  /// `ManuallyDrop` to control drop order (needs to be dropped after all the nodes).
+ // Although some of the accessory types store a copy of the allocator, the nodes do not.
+ // Because allocations will remain live as long as any copy (like this one) of the allocator
+ // is live, it's unnecessary to store the allocator in each node.
  pub(super) alloc: ManuallyDrop<A>,
  // For dropck; the `Box` avoids making the `Unpin` impl more strict than before
  _marker: PhantomData<crate::boxed::Box<(K, V), A>>,
@@ -546,7 +549,11 @@ impl<K, V: fmt::Debug> fmt::Debug for ValuesMut<'_, K, V> {
 /// [`into_keys`]: BTreeMap::into_keys
 #[must_use = "iterators are lazy and do nothing unless consumed"]
 #[stable(feature = "map_into_keys_values", since = "1.54.0")]
-pub struct IntoKeys<K, V, A: Allocator + Clone = Global> {
+pub struct IntoKeys<
+ K,
+ V,
+ #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator + Clone = Global,
+> {
  inner: IntoIter<K, V, A>,
 }
 
@@ -1433,7 +1440,6 @@ impl<K, V, A: Allocator + Clone> BTreeMap<K, V, A> {
  /// # Examples
  ///
  /// ```
- /// #![feature(btree_extract_if)]
  /// use std::collections::BTreeMap;
  ///
  /// // Splitting a map into even and odd keys, reusing the original map:
@@ -1450,7 +1456,7 @@ impl<K, V, A: Allocator + Clone> BTreeMap<K, V, A> {
  /// assert_eq!(low.keys().copied().collect::<Vec<_>>(), [0, 1, 2, 3]);
  /// assert_eq!(high.keys().copied().collect::<Vec<_>>(), [4, 5, 6, 7]);
  /// ```
- #[unstable(feature = "btree_extract_if", issue = "70530")]
+ #[stable(feature = "btree_extract_if", since = "1.91.0")]
  pub fn extract_if<F, R>(&mut self, range: R, pred: F) -> ExtractIf<'_, K, V, R, F, A>
  where
  K: Ord,
@@ -1937,7 +1943,7 @@ impl<K, V> Default for Values<'_, K, V> {
 }
 
 /// An iterator produced by calling `extract_if` on BTreeMap.
-#[unstable(feature = "btree_extract_if", issue = "70530")]
+#[stable(feature = "btree_extract_if", since = "1.91.0")]
 #[must_use = "iterators are lazy and do nothing unless consumed"]
 pub struct ExtractIf<
  'a,
@@ -1970,7 +1976,7 @@ pub(super) struct ExtractIfInner<'a, K, V, R> {
  range: R,
 }
 
-#[unstable(feature = "btree_extract_if", issue = "70530")]
+#[stable(feature = "btree_extract_if", since = "1.91.0")]
 impl<K, V, R, F, A> fmt::Debug for ExtractIf<'_, K, V, R, F, A>
 where
  K: fmt::Debug,
@@ -1982,7 +1988,7 @@ where
  }
 }
 
-#[unstable(feature = "btree_extract_if", issue = "70530")]
+#[stable(feature = "btree_extract_if", since = "1.91.0")]
 impl<K, V, R, F, A: Allocator + Clone> Iterator for ExtractIf<'_, K, V, R, F, A>
 where
  K: PartialOrd,
@@ -2056,7 +2062,7 @@ impl<'a, K, V, R> ExtractIfInner<'a, K, V, R> {
  }
 }
 
-#[unstable(feature = "btree_extract_if", issue = "70530")]
+#[stable(feature = "btree_extract_if", since = "1.91.0")]
 impl<K, V, R, F> FusedIterator for ExtractIf<'_, K, V, R, F>
 where
  K: PartialOrd,
@@ -2407,7 +2413,7 @@ impl<K, V> Default for BTreeMap<K, V> {
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<K: PartialEq, V: PartialEq, A: Allocator + Clone> PartialEq for BTreeMap<K, V, A> {
  fn eq(&self, other: &BTreeMap<K, V, A>) -> bool {
- self.len() == other.len() && self.iter().zip(other).all(|(a, b)| a == b)
+ self.iter().eq(other)
  }
 }
 

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

@@ -99,7 +99,12 @@ impl<K: Debug + Ord, V: Debug, A: Allocator + Clone> Debug for OccupiedEntry<'_,
 ///
 /// Contains the occupied entry, and the value that was not inserted.
 #[unstable(feature = "map_try_insert", issue = "82766")]
-pub struct OccupiedError<'a, K: 'a, V: 'a, A: Allocator + Clone = Global> {
+pub struct OccupiedError<
+ 'a,
+ K: 'a,
+ V: 'a,
+ #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator + Clone = Global,
+> {
  /// The entry in the map that was already occupied.
  pub entry: OccupiedEntry<'a, K, V, A>,
  /// The value which was not inserted, because the entry was already occupied.
@@ -271,7 +276,6 @@ impl<'a, K: Ord, V, A: Allocator + Clone> Entry<'a, K, V, A> {
  /// # Examples
  ///
  /// ```
- /// #![feature(btree_entry_insert)]
  /// use std::collections::BTreeMap;
  ///
  /// let mut map: BTreeMap<&str, String> = BTreeMap::new();
@@ -280,7 +284,7 @@ impl<'a, K: Ord, V, A: Allocator + Clone> Entry<'a, K, V, A> {
  /// assert_eq!(entry.key(), &"poneyland");
  /// ```
  #[inline]
- #[unstable(feature = "btree_entry_insert", issue = "65225")]
+ #[stable(feature = "btree_entry_insert", since = "CURRENT_RUSTC_VERSION")]
  pub fn insert_entry(self, value: V) -> OccupiedEntry<'a, K, V, A> {
  match self {
  Occupied(mut entry) => {
@@ -379,7 +383,6 @@ impl<'a, K: Ord, V, A: Allocator + Clone> VacantEntry<'a, K, V, A> {
  /// # Examples
  ///
  /// ```
- /// #![feature(btree_entry_insert)]
  /// use std::collections::BTreeMap;
  /// use std::collections::btree_map::Entry;
  ///
@@ -391,7 +394,7 @@ impl<'a, K: Ord, V, A: Allocator + Clone> VacantEntry<'a, K, V, A> {
  /// }
  /// assert_eq!(map["poneyland"], 37);
  /// ```
- #[unstable(feature = "btree_entry_insert", issue = "65225")]
+ #[stable(feature = "btree_entry_insert", since = "CURRENT_RUSTC_VERSION")]
  pub fn insert_entry(mut self, value: V) -> OccupiedEntry<'a, K, V, A> {
  let handle = match self.handle {
  None => {