Merge subtree update for toolchain nightly-2026-10-11

.github/workflows/flux.yml

@@ -8,8 +8,8 @@ on:
     branches: [main]
 
 env:
-  FLUX_VERSION: "849ef7c31ce06ec92e211050ac2f5bc8c543896d"
-  FIXPOINT_VERSION: "nightly-2026-07-20"
+  FLUX_VERSION: "6769bb9cbd1216380f542349494efafafd6104a3"
+  FIXPOINT_VERSION: "nightly"
 
 jobs:
   check-flux-on-core:

library/alloc/Cargo.toml

@@ -32,3 +32,7 @@ check-cfg = [
     'cfg(no_rc)',
     'cfg(no_sync)',
 ]
+
+[lints.cargo]
+# compiler-builtins is claimed unused?
+unused_dependencies = "allow"

library/alloc/src/alloc.rs

@@ -43,15 +43,42 @@ unsafe extern "Rust" {
     fn __rust_no_alloc_shim_is_unstable_v2();
 }
 
-/// The global memory allocator.
+/// A wrapper for the global allocator.
 ///
 /// This type implements the [`Allocator`] trait by forwarding calls
 /// to the allocator registered with the `#[global_allocator]` attribute
 /// if there is one, or the `std` crate’s default.
 ///
-/// Note: while this type is unstable, the functionality it provides can be
-/// accessed through the [free functions in `alloc`](self#functions).
-#[stable(feature = "allocator_api", since = "CURRENT_RUSTC_VERSION")]
+/// `Global` is not "the global allocator", but a wrapper for it.
+/// If the global allocator used `Global`, it would call itself recursively.
+/// To avoid this, `Global` does not implement [`GlobalAlloc`].
+///
+/// Similar to [`alloc`], [`dealloc`], and the other global allocation functions,
+/// when and how calls are forwarded to the allocator registered with
+/// `#[global_allocator]` is unspecified. See their safety docs for more information.
+///
+/// In particular, even if you know which allocator was registered
+/// as the global allocator, calling it directly is not the same as calling
+/// `Global`. You cannot deallocate memory from one using the other.
+///
+/// `Global` must be treated like an opaque allocator that only guarantees the contract
+/// described in the docs of [`Allocator`], as well as the following:
+/// * All instances of `Global` are [*equivalent*].
+/// * Allocations from `Global` are only invalidated by calls to de-/reallocating functions.
+///   If no such call is made, then the allocation will live for the rest of the program.
+/// * The global allocation functions in the [`alloc`](self) module are equivalent to the
+///   methods on `Global`, except that they disallow zero-sized allocations, and implicitly
+///   ignore any returned excess size.
+///   In particular, you may deallocate memory from [`alloc::alloc`](self::alloc) using
+///   [`Global.deallocate`](Global::deallocate) and vice-versa.
+///
+/// Note that the current implementation of `Global` does not take advantage of
+/// some features of [`Allocator`], such as zero-sized allocations (which currently
+/// return a dangling pointer) and overallocating.
+/// This may change in the future. You must not rely on it for correctness!
+///
+/// [*equivalent*]: Allocator#equivalent-allocators
+#[stable(feature = "allocator_api", since = "1.100.0")]
 #[derive(Copy, Debug)]
 #[derive_const(Clone, Default)]
 // the compiler needs to know when a Box uses the global allocator vs a custom one
@@ -539,7 +566,7 @@ impl Global {
     }
 }
 
-#[stable(feature = "allocator_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "allocator_api", since = "1.100.0")]
 #[rustc_const_unstable(feature = "const_heap", issue = "79597")]
 const unsafe impl Allocator for Global {
     #[inline]
@@ -676,27 +703,5 @@ pub mod __alloc_error_handler {
     }
 }
 
-/// Allocator marker trait that is implemented only on `Global`, except when
-/// the allocator feature gate is enabled (in which case it is implemented
-/// for all allocators).
-///
-/// This is to prevent stable code from e.g. constructing `Arc<T, NotGlobal>`
-/// using the `From<Box<T, A>> for Arc<T, A>` impl.
-///
-/// Note that this trait cannot appear in specialization impls (even if not
-/// specialized on).
-///
-/// This trait should be used as a bound whenever a function constructing
-/// a type with an `#[unstable] A: Allocator = Global` parameter may be
-/// callable for `A != Global`.
-#[marker]
-#[unstable(feature = "allocator_ext", issue = "163177", implied_by = "allocator_api")]
-#[doc(hidden)]
-pub trait AllocatorNightly: Allocator {}
-
-#[unstable(feature = "allocator_ext", issue = "163177", implied_by = "allocator_api")]
-#[unstable_feature_bound(allocator_ext)]
-impl<A: Allocator + ?Sized> AllocatorNightly for A {}
-
 #[unstable(feature = "allocator_ext", issue = "163177", implied_by = "allocator_api")]
 impl AllocatorNightly for Global {}

library/alloc/src/boxed.rs

@@ -190,7 +190,7 @@ use core::error::{self, Error};
 use core::fmt;
 use core::future::Future;
 use core::hash::{Hash, Hasher};
-use core::marker::{Tuple, Unsize};
+use core::marker::{PhantomData, Tuple, Unsize};
 #[cfg(not(no_global_oom_handling))]
 use core::mem::MaybeUninit;
 use core::mem::{self, SizedTypeProperties};
@@ -201,12 +201,12 @@ use core::ops::{
 #[cfg(not(no_global_oom_handling))]
 use core::ops::{Residual, Try};
 use core::pin::{Pin, PinSafePointer};
-use core::ptr::{self, NonNull, Unique};
+use core::ptr::{self, NonNull};
 use core::task::{Context, Poll};
 
 #[cfg(not(no_global_oom_handling))]
 use crate::alloc::handle_alloc_error;
-use crate::alloc::{AllocError, Allocator, Global, Layout, StaticAllocator};
+use crate::alloc::{AllocError, Allocator, AllocatorNightly, Global, Layout, StaticAllocator};
 use crate::raw_vec::RawVec;
 #[cfg(not(no_global_oom_handling))]
 use crate::str::from_boxed_utf8_unchecked_in;
@@ -223,6 +223,71 @@ pub use iter::BoxedArrayIntoIter;
 #[unstable(feature = "thin_box", issue = "92791")]
 pub use thin::ThinBox;
 
+/// An internal wrapper for the pointer + `PhantomData` inside a `Box`.
+/// This type has no semantic meaning. It only exists because the layout of
+/// `Box` is hard-coded into the compiler, and because moving the
+/// auto trait impls to `Box` would cause regressions (#162850).
+#[repr(transparent)]
+struct BoxRaw<T: ?Sized> {
+    pointer: NonNull<T>,
+    _marker: PhantomData<T>,
+}
+
+unsafe impl<T: ?Sized + Send> Send for BoxRaw<T> {}
+unsafe impl<T: ?Sized + Sync> Sync for BoxRaw<T> {}
+impl<T: ?Sized + core::panic::UnwindSafe> core::panic::UnwindSafe for BoxRaw<T> {}
+impl<T: ?Sized, U: ?Sized> CoerceUnsized<BoxRaw<U>> for BoxRaw<T> where T: Unsize<U> {}
+impl<T: ?Sized, U: ?Sized> DispatchFromDyn<BoxRaw<U>> for BoxRaw<T> where T: Unsize<U> {}
+
+impl<T: ?Sized> BoxRaw<T> {
+    /// # Safety
+    /// `ptr` must be non-null
+    #[inline]
+    const unsafe fn new_unchecked(ptr: *mut T) -> Self {
+        // SAFETY: Upheld by the caller
+        unsafe { BoxRaw { pointer: NonNull::new_unchecked(ptr), _marker: PhantomData } }
+    }
+
+    #[inline]
+    const fn cast<U>(self) -> BoxRaw<U> {
+        BoxRaw { pointer: self.pointer.cast(), _marker: PhantomData }
+    }
+
+    #[inline]
+    const fn as_non_null_ptr(self) -> NonNull<T> {
+        self.pointer
+    }
+
+    #[inline]
+    const fn as_ptr(self) -> *mut T {
+        self.pointer.as_ptr()
+    }
+
+    #[inline]
+    #[cfg(not(no_global_oom_handling))]
+    const fn dangling() -> Self
+    where
+        T: Sized,
+    {
+        BoxRaw { pointer: NonNull::dangling(), _marker: PhantomData }
+    }
+}
+
+impl<T: ?Sized> Clone for BoxRaw<T> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl<T: ?Sized> Copy for BoxRaw<T> {}
+
+#[expect(ineffective_unstable_trait_impl, reason = "See #164109")]
+#[unstable(feature = "box_internals", issue = "none")]
+impl<T: ?Sized> From<BoxRaw<T>> for NonNull<T> {
+    fn from(value: BoxRaw<T>) -> Self {
+        value.as_non_null_ptr()
+    }
+}
+
 /// A pointer type that uniquely owns a heap allocation of type `T`.
 ///
 /// See the [module-level documentation](../../std/boxed/index.html) for more.
@@ -235,8 +300,8 @@ pub use thin::ThinBox;
 // compiler or ICEs will happen.
 pub struct Box<
     T: ?Sized,
-    #[stable(feature = "allocator_api", since = "CURRENT_RUSTC_VERSION")] A: Allocator = Global,
->(Unique<T>, A);
+    #[stable(feature = "allocator_api", since = "1.100.0")] A: Allocator = Global,
+>(BoxRaw<T>, A);
 
 /// Monomorphic function for allocating an uninit `Box`.
 #[inline]
@@ -248,6 +313,9 @@ pub struct Box<
 #[cfg(not(no_global_oom_handling))]
 #[rustc_const_unstable(feature = "const_heap", issue = "79597")]
 const fn box_new_uninit(layout: Layout) -> *mut u8 {
+    if layout.size() == 0 {
+        return layout.dangling_ptr().as_ptr();
+    }
     match Global.allocate(layout) {
         Ok(ptr) => ptr.as_mut_ptr(),
         Err(_) => handle_alloc_error(layout),
@@ -443,7 +511,7 @@ impl<T, A: Allocator> Box<T, A> {
     /// let five = Box::new_in(5, System);
     /// ```
     #[cfg(not(no_global_oom_handling))]
-    #[stable(feature = "allocator_api", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "allocator_api", since = "1.100.0")]
     #[must_use]
     #[inline]
     pub fn new_in(x: T, alloc: A) -> Self {
@@ -676,7 +744,7 @@ impl<T, A: Allocator> Box<T, A> {
     /// let c = Box::write(uninit, 6);
     /// assert_eq!(*c, 6);
     /// ```
-    #[stable(feature = "box_take", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "box_take", since = "1.100.0")]
     pub fn take(boxed: Self) -> (T, Box<mem::MaybeUninit<T>, A>) {
         // SAFETY: Reading out an initialised value & leaving behind a
         // box with uninit contents.
@@ -704,7 +772,7 @@ impl<T, A: Allocator> Box<T, A> {
     /// assert_eq!(*new, 14);
     /// ```
     #[cfg(not(no_global_oom_handling))]
-    #[stable(feature = "smart_pointer_map", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "smart_pointer_map", since = "1.100.0")]
     pub fn map<U>(this: Self, f: impl FnOnce(T) -> U) -> Box<U, A> {
         let (value, allocation) = Box::take(this);
         let (raw, alloc) = Box::into_non_null_with_allocator(allocation);
@@ -1562,11 +1630,11 @@ impl<T: ?Sized, A: Allocator> Box<T, A> {
     ///
     /// [memory layout]: self#memory-layout
     /// [considerations for unsafe code]: self#considerations-for-unsafe-code
-    #[stable(feature = "allocator_api", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "allocator_api", since = "1.100.0")]
     #[inline]
     pub unsafe fn from_raw_in(raw: *mut T, alloc: A) -> Self {
         // SAFETY: Upheld by caller.
-        Box(unsafe { Unique::new_unchecked(raw) }, alloc)
+        Box(unsafe { BoxRaw::new_unchecked(raw) }, alloc)
     }
 
     /// Constructs a box from a `NonNull` pointer in the given allocator.
@@ -1615,7 +1683,7 @@ impl<T: ?Sized, A: Allocator> Box<T, A> {
     ///
     /// [memory layout]: self#memory-layout
     /// [considerations for unsafe code]: self#considerations-for-unsafe-code
-    #[stable(feature = "allocator_api", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "allocator_api", since = "1.100.0")]
     #[inline]
     pub unsafe fn from_non_null_in(raw: NonNull<T>, alloc: A) -> Self {
         // SAFETY: guaranteed by the caller.
@@ -1665,7 +1733,7 @@ impl<T: ?Sized, A: Allocator> Box<T, A> {
     ///
     /// [memory layout]: self#memory-layout
     #[must_use = "losing the pointer will leak memory"]
-    #[stable(feature = "allocator_api", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "allocator_api", since = "1.100.0")]
     #[rustc_const_unstable(feature = "const_heap", issue = "79597")]
     #[inline]
     pub const fn into_raw_with_allocator(b: Self) -> (*mut T, A) {
@@ -1723,7 +1791,7 @@ impl<T: ?Sized, A: Allocator> Box<T, A> {
     ///
     /// [memory layout]: self#memory-layout
     #[must_use = "losing the pointer will leak memory"]
-    #[stable(feature = "allocator_api", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "allocator_api", since = "1.100.0")]
     #[inline]
     pub fn into_non_null_with_allocator(b: Self) -> (NonNull<T>, A) {
         let (ptr, alloc) = Box::into_raw_with_allocator(b);
@@ -1869,7 +1937,7 @@ impl<T: ?Sized, A: Allocator> Box<T, A> {
     /// Note: this is an associated function, which means that you have
     /// to call it as `Box::allocator(&b)` instead of `b.allocator()`. This
     /// is so that there is no conflict with a method on the inner type.
-    #[stable(feature = "allocator_api", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "allocator_api", since = "1.100.0")]
     #[inline]
     pub fn allocator(b: &Self) -> &A {
         &b.1
@@ -2024,7 +2092,9 @@ impl<T> Default for Box<[T]> {
     /// Creates an empty `[T]` inside a `Box`.
     #[inline]
     fn default() -> Self {
-        let ptr: Unique<[T]> = Unique::<[T; 0]>::dangling();
+        let ptr: BoxRaw<[T]> = BoxRaw::<[T; 0]>::dangling();
+        // SAFETY: `[T; 0]` is a ZST, for which `dangling` is valid to turn into a `Box`,
+        // even after unsize coercion.
         Box(ptr, Global)
     }
 }
@@ -2034,10 +2104,13 @@ impl<T> Default for Box<[T]> {
 impl Default for Box<str> {
     #[inline]
     fn default() -> Self {
-        // SAFETY: This is the same as `Unique::cast<U>` but with an unsized `U = str`.
-        let ptr: Unique<str> = unsafe {
-            let bytes: Unique<[u8]> = Unique::<[u8; 0]>::dangling();
-            Unique::new_unchecked(bytes.as_ptr() as *mut str)
+        // SAFETY:
+        // - `[u8; 0]` is a ZST, for which `dangling` is valid to turn into a `Box`
+        // - Casting `[u8]` to `str` is correct
+        // - The empty byte slice is valid UTF-8
+        let ptr: BoxRaw<str> = unsafe {
+            let bytes: BoxRaw<[u8]> = BoxRaw::<[u8; 0]>::dangling();
+            BoxRaw::new_unchecked(bytes.as_ptr() as *mut str)
         };
         Box(ptr, Global)
     }
@@ -2455,7 +2528,7 @@ impl<G: ?Sized + Coroutine<R> + Unpin, R, A: Allocator> Coroutine<R> for Box<G,
 #[unstable(feature = "coroutine_trait", issue = "43122")]
 impl<G: ?Sized + Coroutine<R>, R, A: Allocator> Coroutine<R> for Pin<Box<G, A>>
 where
-    A: 'static,
+    A: StaticAllocator,
 {
     type Yield = G::Yield;
     type Return = G::Return;
@@ -2490,7 +2563,7 @@ impl<E: Error, A: Allocator> Error for Box<E, A> {
     }
 }
 
-#[stable(feature = "allocator_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "allocator_api", since = "1.100.0")]
 unsafe impl<T: ?Sized + Allocator, A: Allocator> Allocator for Box<T, A> {
     #[inline]
     fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {
@@ -2541,6 +2614,9 @@ unsafe impl<T: ?Sized + Allocator, A: Allocator> Allocator for Box<T, A> {
         unsafe { (**self).shrink(ptr, old_layout, new_layout) }
     }
 }
+#[unstable(feature = "allocator_ext", issue = "163177", implied_by = "allocator_api")]
+#[unstable_feature_bound(allocator_ext)]
+impl<T: ?Sized + Allocator, A: Allocator> AllocatorNightly for Box<T, A> {}
 
 #[unstable(feature = "random", issue = "130703")]
 impl<R: core::random::Rng + ?Sized, A: Allocator> core::random::Rng for Box<R, A> {

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

@@ -205,8 +205,17 @@ pub struct BTreeMap<
 #[stable(feature = "btree_drop", since = "1.7.0")]
 unsafe impl<#[may_dangle] K, #[may_dangle] V, A: AllocatorClone> Drop for BTreeMap<K, V, A> {
     fn drop(&mut self) {
-        // ignore-tidy-undocumented-unsafe
-        drop(unsafe { ptr::read(self) }.into_iter())
+        // Skip `into_iter` for an empty map: `dying_next` is too costly to inline, so the
+        // empty drop isn't optimised away (see #161375).
+        if self.root.is_some() {
+            // SAFETY: `self` is not used after this and none of its fields are dropped again:
+            // `alloc` is `ManuallyDrop` and `root` has no drop glue.
+            drop(unsafe { ptr::read(self) }.into_iter())
+        } else {
+            // SAFETY: With no root there are no nodes to free, so only the allocator needs
+            // dropping. `self` is not used after this, and `alloc` is dropped only here.
+            unsafe { ManuallyDrop::drop(&mut self.alloc) }
+        }
     }
 }
 

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

@@ -19,7 +19,7 @@ pub(super) fn replace<T, R>(v: &mut T, change: impl FnOnce(T) -> (T, R)) -> R {
     struct PanicGuard;
     impl Drop for PanicGuard {
         fn drop(&mut self) {
-            intrinsics::abort()
+            intrinsics::abort_immediate()
         }
     }
     let guard = PanicGuard;

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

@@ -61,7 +61,7 @@ impl<K, V> Root<K, V> {
         // A panic from a later `search_node` comparison would unwind out of
         // that state and double-free the shared values (#158165), so abort
         // instead of exposing it.
-        let guard = mem::DropGuard::new((), |()| intrinsics::abort());
+        let guard = mem::DropGuard::new((), |()| intrinsics::abort_immediate());
 
         loop {
             split_edge.move_suffix(&mut right_node);