Auto merge of rust-lang#149397 - matthiaskrgr:rollup-go79y6a, r=matthiaskrgr

Rollup of 8 pull requests

Successful merges:

 - rust-lang#147071 (constify from_fn, try_from_fn, try_map, map)
 - rust-lang#148930 (tweak editor configs)
 - rust-lang#149320 (-Znext-solver: normalize expected function input types when fudging)
 - rust-lang#149363 (Port the `#![windows_subsystem]` attribute to the new attribute system)
 - rust-lang#149378 (make run-make tests use 2024 edition by default)
 - rust-lang#149381 (Add `impl TrustedLen` on `BTree{Map,Set}` iterators)
 - rust-lang#149388 (remove session+blob decoder construction)
 - rust-lang#149390 (`rust-analyzer` subtree update)

r? `@ghost`
`@rustbot` modify labels: rollup

Author: bors

alloc/src/collections/btree/map.rs

@@ -3,7 +3,7 @@ use core::cmp::Ordering;
 use core::error::Error;
 use core::fmt::{self, Debug};
 use core::hash::{Hash, Hasher};
-use core::iter::FusedIterator;
+use core::iter::{FusedIterator, TrustedLen};
 use core::marker::PhantomData;
 use core::mem::{self, ManuallyDrop};
 use core::ops::{Bound, Index, RangeBounds};
@@ -1624,6 +1624,9 @@ impl<K, V> ExactSizeIterator for Iter<'_, K, V> {
     }
 }
 
+#[unstable(feature = "trusted_len", issue = "37572")]
+unsafe impl<K, V> TrustedLen for Iter<'_, K, V> {}
+
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<K, V> Clone for Iter<'_, K, V> {
     fn clone(&self) -> Self {
@@ -1696,6 +1699,9 @@ impl<K, V> ExactSizeIterator for IterMut<'_, K, V> {
     }
 }
 
+#[unstable(feature = "trusted_len", issue = "37572")]
+unsafe impl<K, V> TrustedLen for IterMut<'_, K, V> {}
+
 #[stable(feature = "fused", since = "1.26.0")]
 impl<K, V> FusedIterator for IterMut<'_, K, V> {}
 
@@ -1817,6 +1823,9 @@ impl<K, V, A: Allocator + Clone> ExactSizeIterator for IntoIter<K, V, A> {
     }
 }
 
+#[unstable(feature = "trusted_len", issue = "37572")]
+unsafe impl<K, V, A: Allocator + Clone> TrustedLen for IntoIter<K, V, A> {}
+
 #[stable(feature = "fused", since = "1.26.0")]
 impl<K, V, A: Allocator + Clone> FusedIterator for IntoIter<K, V, A> {}
 
@@ -1865,6 +1874,9 @@ impl<K, V> ExactSizeIterator for Keys<'_, K, V> {
     }
 }
 
+#[unstable(feature = "trusted_len", issue = "37572")]
+unsafe impl<K, V> TrustedLen for Keys<'_, K, V> {}
+
 #[stable(feature = "fused", since = "1.26.0")]
 impl<K, V> FusedIterator for Keys<'_, K, V> {}
 
@@ -1920,6 +1932,9 @@ impl<K, V> ExactSizeIterator for Values<'_, K, V> {
     }
 }
 
+#[unstable(feature = "trusted_len", issue = "37572")]
+unsafe impl<K, V> TrustedLen for Values<'_, K, V> {}
+
 #[stable(feature = "fused", since = "1.26.0")]
 impl<K, V> FusedIterator for Values<'_, K, V> {}
 
@@ -2160,6 +2175,9 @@ impl<K, V> ExactSizeIterator for ValuesMut<'_, K, V> {
     }
 }
 
+#[unstable(feature = "trusted_len", issue = "37572")]
+unsafe impl<K, V> TrustedLen for ValuesMut<'_, K, V> {}
+
 #[stable(feature = "fused", since = "1.26.0")]
 impl<K, V> FusedIterator for ValuesMut<'_, K, V> {}
 
@@ -2222,6 +2240,9 @@ impl<K, V, A: Allocator + Clone> ExactSizeIterator for IntoKeys<K, V, A> {
     }
 }
 
+#[unstable(feature = "trusted_len", issue = "37572")]
+unsafe impl<K, V, A: Allocator + Clone> TrustedLen for IntoKeys<K, V, A> {}
+
 #[stable(feature = "map_into_keys_values", since = "1.54.0")]
 impl<K, V, A: Allocator + Clone> FusedIterator for IntoKeys<K, V, A> {}
 
@@ -2273,6 +2294,9 @@ impl<K, V, A: Allocator + Clone> ExactSizeIterator for IntoValues<K, V, A> {
     }
 }
 
+#[unstable(feature = "trusted_len", issue = "37572")]
+unsafe impl<K, V, A: Allocator + Clone> TrustedLen for IntoValues<K, V, A> {}
+
 #[stable(feature = "map_into_keys_values", since = "1.54.0")]
 impl<K, V, A: Allocator + Clone> FusedIterator for IntoValues<K, V, A> {}
 

alloc/src/collections/btree/set.rs

@@ -3,7 +3,7 @@ use core::cmp::Ordering::{self, Equal, Greater, Less};
 use core::cmp::{max, min};
 use core::fmt::{self, Debug};
 use core::hash::{Hash, Hasher};
-use core::iter::{FusedIterator, Peekable};
+use core::iter::{FusedIterator, Peekable, TrustedLen};
 use core::mem::ManuallyDrop;
 use core::ops::{BitAnd, BitOr, BitXor, Bound, RangeBounds, Sub};
 
@@ -1753,6 +1753,7 @@ impl<T> Clone for Iter<'_, T> {
         Iter { iter: self.iter.clone() }
     }
 }
+
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<'a, T> Iterator for Iter<'a, T> {
     type Item = &'a T;
@@ -1783,19 +1784,24 @@ impl<'a, T> Iterator for Iter<'a, T> {
         self.next_back()
     }
 }
+
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<'a, T> DoubleEndedIterator for Iter<'a, T> {
     fn next_back(&mut self) -> Option<&'a T> {
         self.iter.next_back()
     }
 }
+
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T> ExactSizeIterator for Iter<'_, T> {
     fn len(&self) -> usize {
         self.iter.len()
     }
 }
 
+#[unstable(feature = "trusted_len", issue = "37572")]
+unsafe impl<T> TrustedLen for Iter<'_, T> {}
+
 #[stable(feature = "fused", since = "1.26.0")]
 impl<T> FusedIterator for Iter<'_, T> {}
 
@@ -1832,13 +1838,17 @@ impl<T, A: Allocator + Clone> DoubleEndedIterator for IntoIter<T, A> {
         self.iter.next_back().map(|(k, _)| k)
     }
 }
+
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T, A: Allocator + Clone> ExactSizeIterator for IntoIter<T, A> {
     fn len(&self) -> usize {
         self.iter.len()
     }
 }
 
+#[unstable(feature = "trusted_len", issue = "37572")]
+unsafe impl<T, A: Allocator + Clone> TrustedLen for IntoIter<T, A> {}
+
 #[stable(feature = "fused", since = "1.26.0")]
 impl<T, A: Allocator + Clone> FusedIterator for IntoIter<T, A> {}
 

core/src/array/drain.rs

@@ -1,76 +1,108 @@
-use crate::iter::{TrustedLen, UncheckedIterator};
-use crate::mem::ManuallyDrop;
-use crate::ptr::drop_in_place;
-use crate::slice;
+use crate::marker::{Destruct, PhantomData};
+use crate::mem::{ManuallyDrop, SizedTypeProperties, conjure_zst};
+use crate::ptr::{NonNull, drop_in_place, from_raw_parts_mut, null_mut};
 
-/// A situationally-optimized version of `array.into_iter().for_each(func)`.
-///
-/// [`crate::array::IntoIter`]s are great when you need an owned iterator, but
-/// storing the entire array *inside* the iterator like that can sometimes
-/// pessimize code.  Notable, it can be more bytes than you really want to move
-/// around, and because the array accesses index into it SRoA has a harder time
-/// optimizing away the type than it does iterators that just hold a couple pointers.
-///
-/// Thus this function exists, which gives a way to get *moved* access to the
-/// elements of an array using a small iterator -- no bigger than a slice iterator.
-///
-/// The function-taking-a-closure structure makes it safe, as it keeps callers
-/// from looking at already-dropped elements.
-pub(crate) fn drain_array_with<T, R, const N: usize>(
-    array: [T; N],
-    func: impl for<'a> FnOnce(Drain<'a, T>) -> R,
-) -> R {
-    let mut array = ManuallyDrop::new(array);
-    // SAFETY: Now that the local won't drop it, it's ok to construct the `Drain` which will.
-    let drain = Drain(array.iter_mut());
-    func(drain)
+impl<'l, 'f, T, U, const N: usize, F: FnMut(T) -> U> Drain<'l, 'f, T, N, F> {
+    /// This function returns a function that lets you index the given array in const.
+    /// As implemented it can optimize better than iterators, and can be constified.
+    /// It acts like a sort of guard (owns the array) and iterator combined, which can be implemented
+    /// as it is a struct that implements const fn;
+    /// in that regard it is somewhat similar to an array::Iter implementing `UncheckedIterator`.
+    /// The only method you're really allowed to call is `next()`,
+    /// anything else is more or less UB, hence this function being unsafe.
+    /// Moved elements will not be dropped.
+    /// This will also not actually store the array.
+    ///
+    /// SAFETY: must only be called `N` times. Thou shalt not drop the array either.
+    // FIXME(const-hack): this is a hack for `let guard = Guard(array); |i| f(guard[i])`.
+    #[rustc_const_unstable(feature = "array_try_map", issue = "79711")]
+    pub(super) const unsafe fn new(array: &'l mut ManuallyDrop<[T; N]>, f: &'f mut F) -> Self {
+        // dont drop the array, transfers "ownership" to Self
+        let ptr: NonNull<T> = NonNull::from_mut(array).cast();
+        // SAFETY:
+        // Adding `slice.len()` to the starting pointer gives a pointer
+        // at the end of `slice`. `end` will never be dereferenced, only checked
+        // for direct pointer equality with `ptr` to check if the drainer is done.
+        unsafe {
+            let end = if T::IS_ZST { null_mut() } else { ptr.as_ptr().add(N) };
+            Self { ptr, end, f, l: PhantomData }
+        }
+    }
 }
 
-/// See [`drain_array_with`] -- this is `pub(crate)` only so it's allowed to be
-/// mentioned in the signature of that method.  (Otherwise it hits `E0446`.)
-// INVARIANT: It's ok to drop the remainder of the inner iterator.
-pub(crate) struct Drain<'a, T>(slice::IterMut<'a, T>);
+/// See [`Drain::new`]; this is our fake iterator.
+#[rustc_const_unstable(feature = "array_try_map", issue = "79711")]
+#[unstable(feature = "array_try_map", issue = "79711")]
+pub(super) struct Drain<'l, 'f, T, const N: usize, F> {
+    // FIXME(const-hack): This is essentially a slice::IterMut<'static>, replace when possible.
+    /// The pointer to the next element to return, or the past-the-end location
+    /// if the drainer is empty.
+    ///
+    /// This address will be used for all ZST elements, never changed.
+    /// As we "own" this array, we dont need to store any lifetime.
+    ptr: NonNull<T>,
+    /// For non-ZSTs, the non-null pointer to the past-the-end element.
+    /// For ZSTs, this is null.
+    end: *mut T,
 
-impl<T> Drop for Drain<'_, T> {
-    fn drop(&mut self) {
-        // SAFETY: By the type invariant, we're allowed to drop all these.
-        unsafe { drop_in_place(self.0.as_mut_slice()) }
-    }
+    f: &'f mut F,
+    l: PhantomData<&'l mut [T; N]>,
 }
 
-impl<T> Iterator for Drain<'_, T> {
-    type Item = T;
-
-    #[inline]
-    fn next(&mut self) -> Option<T> {
-        let p: *const T = self.0.next()?;
-        // SAFETY: The iterator was already advanced, so we won't drop this later.
-        Some(unsafe { p.read() })
-    }
+#[rustc_const_unstable(feature = "array_try_map", issue = "79711")]
+#[unstable(feature = "array_try_map", issue = "79711")]
+impl<T, U, const N: usize, F> const FnOnce<(usize,)> for &mut Drain<'_, '_, T, N, F>
+where
+    F: [const] FnMut(T) -> U,
+{
+    type Output = U;
 
-    #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        let n = self.len();
-        (n, Some(n))
+    /// This implementation is useless.
+    extern "rust-call" fn call_once(mut self, args: (usize,)) -> Self::Output {
+        self.call_mut(args)
     }
 }
-
-impl<T> ExactSizeIterator for Drain<'_, T> {
-    #[inline]
-    fn len(&self) -> usize {
-        self.0.len()
+#[rustc_const_unstable(feature = "array_try_map", issue = "79711")]
+#[unstable(feature = "array_try_map", issue = "79711")]
+impl<T, U, const N: usize, F> const FnMut<(usize,)> for &mut Drain<'_, '_, T, N, F>
+where
+    F: [const] FnMut(T) -> U,
+{
+    // FIXME(const-hack): ideally this would be an unsafe fn `next()`, and to use it you would instead `|_| unsafe { drain.next() }`.
+    extern "rust-call" fn call_mut(
+        &mut self,
+        (_ /* ignore argument */,): (usize,),
+    ) -> Self::Output {
+        if T::IS_ZST {
+            // its UB to call this more than N times, so returning more ZSTs is valid.
+            // SAFETY: its a ZST? we conjur.
+            (self.f)(unsafe { conjure_zst::<T>() })
+        } else {
+            // increment before moving; if `f` panics, we drop the rest.
+            let p = self.ptr;
+            // SAFETY: caller guarantees never called more than N times (see `Drain::new`)
+            self.ptr = unsafe { self.ptr.add(1) };
+            // SAFETY: we are allowed to move this.
+            (self.f)(unsafe { p.read() })
+        }
     }
 }
+#[rustc_const_unstable(feature = "array_try_map", issue = "79711")]
+#[unstable(feature = "array_try_map", issue = "79711")]
+impl<T: [const] Destruct, const N: usize, F> const Drop for Drain<'_, '_, T, N, F> {
+    fn drop(&mut self) {
+        if !T::IS_ZST {
+            // SAFETY: we cant read more than N elements
+            let slice = unsafe {
+                from_raw_parts_mut::<[T]>(
+                    self.ptr.as_ptr(),
+                    // SAFETY: `start <= end`
+                    self.end.offset_from_unsigned(self.ptr.as_ptr()),
+                )
+            };
 
-// SAFETY: This is a 1:1 wrapper for a slice iterator, which is also `TrustedLen`.
-unsafe impl<T> TrustedLen for Drain<'_, T> {}
-
-impl<T> UncheckedIterator for Drain<'_, T> {
-    unsafe fn next_unchecked(&mut self) -> T {
-        // SAFETY: `Drain` is 1:1 with the inner iterator, so if the caller promised
-        // that there's an element left, the inner iterator has one too.
-        let p: *const T = unsafe { self.0.next_unchecked() };
-        // SAFETY: The iterator was already advanced, so we won't drop this later.
-        unsafe { p.read() }
+            // SAFETY: By the type invariant, we're allowed to drop all these. (we own it, after all)
+            unsafe { drop_in_place(slice) }
+        }
     }
 }