Merge ref '6244effd0372' from rust-lang/rust

Pull recent changes from https://github.com/rust-lang/rust via Josh.

Upstream ref: 6244eff
Filtered ref: 2b788f903ef58db43f16530dbf73f4a0502e4452
Upstream diff: rust-lang/rust@96fe3c3...6244eff

This merge was created using https://github.com/rust-lang/josh-sync.

Author: The Miri Cronjob Bot

alloc/src/collections/vec_deque/tests.rs

@@ -367,7 +367,7 @@ fn test_rotate_right_panic() {
 
 #[test]
 fn test_binary_search() {
-    // If the givin VecDeque is not sorted, the returned result is unspecified and meaningless,
+    // If the given VecDeque is not sorted, the returned result is unspecified and meaningless,
     // as this method performs a binary search.
 
     let tester: VecDeque<_> = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55].into();
@@ -391,7 +391,7 @@ fn test_binary_search() {
 
 #[test]
 fn test_binary_search_by() {
-    // If the givin VecDeque is not sorted, the returned result is unspecified and meaningless,
+    // If the given VecDeque is not sorted, the returned result is unspecified and meaningless,
     // as this method performs a binary search.
 
     let tester: VecDeque<_> = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55].into();
@@ -406,7 +406,7 @@ fn test_binary_search_by() {
 
 #[test]
 fn test_binary_search_key() {
-    // If the givin VecDeque is not sorted, the returned result is unspecified and meaningless,
+    // If the given VecDeque is not sorted, the returned result is unspecified and meaningless,
     // as this method performs a binary search.
 
     let tester: VecDeque<_> = [

alloc/src/string.rs

@@ -2378,6 +2378,28 @@ impl<'a> FromIterator<Cow<'a, str>> for String {
     }
 }
 
+#[cfg(not(no_global_oom_handling))]
+#[unstable(feature = "ascii_char", issue = "110998")]
+impl FromIterator<core::ascii::Char> for String {
+    fn from_iter<T: IntoIterator<Item = core::ascii::Char>>(iter: T) -> Self {
+        let buf = iter.into_iter().map(core::ascii::Char::to_u8).collect();
+        // SAFETY: `buf` is guaranteed to be valid UTF-8 because the `core::ascii::Char` type
+        // only contains ASCII values (0x00-0x7F), which are valid UTF-8.
+        unsafe { String::from_utf8_unchecked(buf) }
+    }
+}
+
+#[cfg(not(no_global_oom_handling))]
+#[unstable(feature = "ascii_char", issue = "110998")]
+impl<'a> FromIterator<&'a core::ascii::Char> for String {
+    fn from_iter<T: IntoIterator<Item = &'a core::ascii::Char>>(iter: T) -> Self {
+        let buf = iter.into_iter().copied().map(core::ascii::Char::to_u8).collect();
+        // SAFETY: `buf` is guaranteed to be valid UTF-8 because the `core::ascii::Char` type
+        // only contains ASCII values (0x00-0x7F), which are valid UTF-8.
+        unsafe { String::from_utf8_unchecked(buf) }
+    }
+}
+
 #[cfg(not(no_global_oom_handling))]
 #[stable(feature = "rust1", since = "1.0.0")]
 impl Extend<char> for String {
@@ -3184,6 +3206,14 @@ impl<'a> FromIterator<String> for Cow<'a, str> {
     }
 }
 
+#[cfg(not(no_global_oom_handling))]
+#[unstable(feature = "ascii_char", issue = "110998")]
+impl<'a> FromIterator<core::ascii::Char> for Cow<'a, str> {
+    fn from_iter<T: IntoIterator<Item = core::ascii::Char>>(it: T) -> Self {
+        Cow::Owned(FromIterator::from_iter(it))
+    }
+}
+
 #[stable(feature = "from_string_for_vec_u8", since = "1.14.0")]
 impl From<String> for Vec<u8> {
     /// Converts the given [`String`] to a vector [`Vec`] that holds values of type [`u8`].

core/src/asserting.rs

@@ -73,12 +73,14 @@ where
 
 // ***** Others *****
 
+//spellchecker:off
 /// All possible captured `assert!` elements
 ///
 /// # Types
 ///
 /// * `E`: **E**lement that is going to be displayed.
 /// * `M`: **M**arker used to differentiate [Capture]s in regards to [Debug].
+//spellchecker:on
 #[unstable(feature = "generic_assert_internals", issue = "44838")]
 pub struct Capture<E, M> {
     // If None, then `E` does not implements [Printable] or `E` wasn't evaluated (`assert!( ... )`

core/src/cell.rs

@@ -252,7 +252,7 @@
 
 use crate::cmp::Ordering;
 use crate::fmt::{self, Debug, Display};
-use crate::marker::{PhantomData, Unsize};
+use crate::marker::{Destruct, PhantomData, Unsize};
 use crate::mem::{self, ManuallyDrop};
 use crate::ops::{self, CoerceUnsized, Deref, DerefMut, DerefPure, DispatchFromDyn};
 use crate::panic::const_panic;
@@ -429,7 +429,11 @@ impl<T> Cell<T> {
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn set(&self, val: T) {
+    #[rustc_const_unstable(feature = "const_cell_traits", issue = "147787")]
+    pub const fn set(&self, val: T)
+    where
+        T: [const] Destruct,
+    {
         self.replace(val);
     }
 
@@ -561,7 +565,12 @@ impl<T: Copy> Cell<T> {
     /// ```
     #[inline]
     #[stable(feature = "cell_update", since = "1.88.0")]
-    pub fn update(&self, f: impl FnOnce(T) -> T) {
+    #[rustc_const_unstable(feature = "const_cell_traits", issue = "147787")]
+    pub const fn update(&self, f: impl [const] FnOnce(T) -> T)
+    where
+        // FIXME(const-hack): `Copy` should imply `const Destruct`
+        T: [const] Destruct,
+    {
         let old = self.get();
         self.set(f(old));
     }
@@ -654,7 +663,11 @@ impl<T: Default> Cell<T> {
     /// assert_eq!(c.into_inner(), 0);
     /// ```
     #[stable(feature = "move_cell", since = "1.17.0")]
-    pub fn take(&self) -> T {
+    #[rustc_const_unstable(feature = "const_cell_traits", issue = "147787")]
+    pub const fn take(&self) -> T
+    where
+        T: [const] Default,
+    {
         self.replace(Default::default())
     }
 }

core/src/lib.rs

@@ -116,6 +116,7 @@
 #![feature(link_cfg)]
 #![feature(offset_of_enum)]
 #![feature(panic_internals)]
+#![feature(pattern_type_macro)]
 #![feature(ptr_alignment_type)]
 #![feature(ptr_metadata)]
 #![feature(set_ptr_value)]
@@ -171,6 +172,7 @@
 #![feature(never_type)]
 #![feature(no_core)]
 #![feature(optimize_attribute)]
+#![feature(pattern_types)]
 #![feature(prelude_import)]
 #![feature(reborrow)]
 #![feature(repr_simd)]

core/src/panic/unwind_safe.rs

@@ -101,9 +101,9 @@ pub auto trait UnwindSafe {}
 #[rustc_diagnostic_item = "ref_unwind_safe_trait"]
 #[diagnostic::on_unimplemented(
     message = "the type `{Self}` may contain interior mutability and a reference may not be safely \
-               transferrable across a catch_unwind boundary",
+               transferable across a catch_unwind boundary",
     label = "`{Self}` may contain interior mutability and a reference may not be safely \
-             transferrable across a catch_unwind boundary"
+             transferable across a catch_unwind boundary"
 )]
 pub auto trait RefUnwindSafe {}
 

core/src/pat.rs

@@ -1,5 +1,8 @@
 //! Helper module for exporting the `pattern_type` macro
 
+use crate::marker::{Freeze, PointeeSized, Unsize};
+use crate::ops::{CoerceUnsized, DispatchFromDyn};
+
 /// Creates a pattern type.
 /// ```ignore (cannot test this from within core yet)
 /// type Positive = std::pat::pattern_type!(i32 is 1..);
@@ -73,3 +76,16 @@ impl const RangePattern for char {
         }
     }
 }
+
+impl<T: PointeeSized, U: PointeeSized> CoerceUnsized<pattern_type!(*const U is !null)> for pattern_type!(*const T is !null) where
+    T: Unsize<U>
+{
+}
+
+impl<T: DispatchFromDyn<U>, U> DispatchFromDyn<pattern_type!(U is !null)> for pattern_type!(T is !null) {}
+
+impl<T: PointeeSized> Unpin for pattern_type!(*const T is !null) {}
+
+unsafe impl<T: PointeeSized> Freeze for pattern_type!(*const T is !null) {}
+
+unsafe impl<T: PointeeSized> Freeze for pattern_type!(*mut T is !null) {}

coretests/tests/lib.rs

@@ -16,6 +16,7 @@
 #![feature(char_internals)]
 #![feature(char_max_len)]
 #![feature(clone_to_uninit)]
+#![feature(const_cell_traits)]
 #![feature(const_cmp)]
 #![feature(const_convert)]
 #![feature(const_destruct)]

coretests/tests/manually_drop.rs

@@ -27,3 +27,41 @@ fn smoke() {
     drop(x);
     drop(y);
 }
+
+#[test]
+fn const_drop_in_place() {
+    const COUNTER: usize = {
+        use core::cell::Cell;
+
+        let counter = Cell::new(0);
+
+        // only exists to make `Drop` indirect impl
+        #[allow(dead_code)]
+        struct Test<'a>(Dropped<'a>);
+
+        struct Dropped<'a>(&'a Cell<usize>);
+        impl const Drop for Dropped<'_> {
+            fn drop(&mut self) {
+                self.0.set(self.0.get() + 1);
+            }
+        }
+
+        let mut one = ManuallyDrop::new(Test(Dropped(&counter)));
+        let mut two = ManuallyDrop::new(Test(Dropped(&counter)));
+        let mut three = ManuallyDrop::new(Test(Dropped(&counter)));
+        assert!(counter.get() == 0);
+        unsafe {
+            ManuallyDrop::drop(&mut one);
+        }
+        assert!(counter.get() == 1);
+        unsafe {
+            ManuallyDrop::drop(&mut two);
+        }
+        assert!(counter.get() == 2);
+        unsafe {
+            ManuallyDrop::drop(&mut three);
+        }
+        counter.get()
+    };
+    assert_eq!(COUNTER, 3);
+}

coretests/tests/ptr.rs

@@ -1,6 +1,6 @@
 use core::cell::RefCell;
 use core::marker::Freeze;
-use core::mem::{ManuallyDrop, MaybeUninit};
+use core::mem::MaybeUninit;
 use core::num::NonZero;
 use core::ptr;
 use core::ptr::*;
@@ -1045,42 +1045,3 @@ fn test_ptr_default() {
     let default = PtrMutDefaultTest::default();
     assert!(default.ptr.is_null());
 }
-
-#[test]
-fn test_const_drop_in_place() {
-    const COUNTER: usize = {
-        let mut counter = 0;
-        let counter_ptr = &raw mut counter;
-
-        // only exists to make `Drop` indirect impl
-        #[allow(dead_code)]
-        struct Test(Dropped);
-
-        struct Dropped(*mut usize);
-        impl const Drop for Dropped {
-            fn drop(&mut self) {
-                unsafe {
-                    *self.0 += 1;
-                }
-            }
-        }
-
-        let mut one = ManuallyDrop::new(Test(Dropped(counter_ptr)));
-        let mut two = ManuallyDrop::new(Test(Dropped(counter_ptr)));
-        let mut three = ManuallyDrop::new(Test(Dropped(counter_ptr)));
-        assert!(counter == 0);
-        unsafe {
-            ManuallyDrop::drop(&mut one);
-        }
-        assert!(counter == 1);
-        unsafe {
-            ManuallyDrop::drop(&mut two);
-        }
-        assert!(counter == 2);
-        unsafe {
-            ManuallyDrop::drop(&mut three);
-        }
-        counter
-    };
-    assert_eq!(COUNTER, 3);
-}