Rollup of 8 pull requests

compiler/rustc_target/src/spec/base/wasm.rs

@@ -28,16 +28,6 @@ pub(crate) fn options() -> TargetOptions {
                 // stack overflow will be guaranteed to trap as it underflows instead of
                 // corrupting static data.
                 concat!($prefix, "--stack-first"),
-                // FIXME we probably shouldn't pass this but instead pass an explicit list
-                // of symbols we'll allow to be undefined. We don't currently have a
-                // mechanism of knowing, however, which symbols are intended to be imported
-                // from the environment and which are intended to be imported from other
-                // objects linked elsewhere. This is a coarse approximation but is sure to
-                // hide some bugs and frustrate someone at some point, so we should ideally
-                // work towards a world where we can explicitly list symbols that are
-                // supposed to be imported and have all other symbols generate errors if
-                // they remain undefined.
-                concat!($prefix, "--allow-undefined"),
                 // LLD only implements C++-like demangling, which doesn't match our own
                 // mangling scheme. Tell LLD to not demangle anything and leave it up to
                 // us to demangle these symbols later. Currently rustc does not perform

library/alloc/src/boxed.rs

@@ -695,6 +695,15 @@ impl<T, A: Allocator> Box<T, A> {
     /// does the same as <code>[Box::into_pin]\([Box::new_in]\(x, alloc))</code>. Consider using
     /// [`into_pin`](Box::into_pin) if you already have a `Box<T, A>`, or if you want to
     /// construct a (pinned) `Box` in a different way than with [`Box::new_in`].
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(allocator_api)]
+    /// use std::alloc::System;
+    ///
+    /// let x = Box::pin_in(1, System);
+    /// ```
     #[cfg(not(no_global_oom_handling))]
     #[unstable(feature = "allocator_api", issue = "32838")]
     #[must_use]

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

@@ -549,8 +549,8 @@ impl<T, A: Allocator> BinaryHeap<T, A> {
     ///
     /// use std::alloc::System;
     /// use std::collections::BinaryHeap;
-    /// let mut heap = BinaryHeap::new_in(System);
-    /// heap.push(4);
+    ///
+    /// let heap : BinaryHeap<i32, System> = BinaryHeap::new_in(System);
     /// ```
     #[unstable(feature = "allocator_api", issue = "32838")]
     #[must_use]
@@ -573,8 +573,8 @@ impl<T, A: Allocator> BinaryHeap<T, A> {
     ///
     /// use std::alloc::System;
     /// use std::collections::BinaryHeap;
-    /// let mut heap = BinaryHeap::with_capacity_in(10, System);
-    /// heap.push(4);
+    ///
+    /// let heap: BinaryHeap<i32, System> = BinaryHeap::with_capacity_in(10, System);
     /// ```
     #[unstable(feature = "allocator_api", issue = "32838")]
     #[must_use]

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

@@ -684,13 +684,11 @@ impl<K, V, A: Allocator + Clone> BTreeMap<K, V, A> {
     /// ```
     /// # #![feature(allocator_api)]
     /// # #![feature(btreemap_alloc)]
+    ///
     /// use std::collections::BTreeMap;
     /// use std::alloc::Global;
     ///
-    /// let mut map = BTreeMap::new_in(Global);
-    ///
-    /// // entries can now be inserted into the empty map
-    /// map.insert(1, "a");
+    /// let map: BTreeMap<i32, i32> = BTreeMap::new_in(Global);
     /// ```
     #[unstable(feature = "btreemap_alloc", issue = "32838")]
     #[must_use]

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

@@ -355,10 +355,11 @@ impl<T, A: Allocator + Clone> BTreeSet<T, A> {
     /// # #![allow(unused_mut)]
     /// # #![feature(allocator_api)]
     /// # #![feature(btreemap_alloc)]
+    ///
     /// use std::collections::BTreeSet;
     /// use std::alloc::Global;
     ///
-    /// let mut set: BTreeSet<i32> = BTreeSet::new_in(Global);
+    /// let set: BTreeSet<i32> = BTreeSet::new_in(Global);
     /// ```
     #[unstable(feature = "btreemap_alloc", issue = "32838")]
     #[must_use]

library/alloc/src/collections/linked_list.rs

@@ -509,7 +509,7 @@ impl<T, A: Allocator> LinkedList<T, A> {
     /// use std::alloc::System;
     /// use std::collections::LinkedList;
     ///
-    /// let list: LinkedList<u32, _> = LinkedList::new_in(System);
+    /// let list: LinkedList<i32, System> = LinkedList::new_in(System);
     /// ```
     #[inline]
     #[unstable(feature = "allocator_api", issue = "32838")]

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

@@ -790,7 +790,7 @@ impl<T> VecDeque<T> {
     /// ```
     /// use std::collections::VecDeque;
     ///
-    /// let deque: VecDeque<u32> = VecDeque::with_capacity(10);
+    /// let deque: VecDeque<i32> = VecDeque::with_capacity(10);
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
@@ -830,9 +830,12 @@ impl<T, A: Allocator> VecDeque<T, A> {
     /// # Examples
     ///
     /// ```
+    /// # #![feature(allocator_api)]
+    ///
     /// use std::collections::VecDeque;
+    /// use std::alloc::Global;
     ///
-    /// let deque: VecDeque<u32> = VecDeque::new();
+    /// let deque: VecDeque<i32> = VecDeque::new_in(Global);
     /// ```
     #[inline]
     #[unstable(feature = "allocator_api", issue = "32838")]
@@ -845,9 +848,12 @@ impl<T, A: Allocator> VecDeque<T, A> {
     /// # Examples
     ///
     /// ```
+    /// # #![feature(allocator_api)]
+    ///
     /// use std::collections::VecDeque;
+    /// use std::alloc::Global;
     ///
-    /// let deque: VecDeque<u32> = VecDeque::with_capacity(10);
+    /// let deque: VecDeque<i32> = VecDeque::with_capacity_in(10, Global);
     /// ```
     #[unstable(feature = "allocator_api", issue = "32838")]
     pub fn with_capacity_in(capacity: usize, alloc: A) -> VecDeque<T, A> {

library/alloc/src/rc.rs

@@ -737,6 +737,7 @@ impl<T, A: Allocator> Rc<T, A> {
     ///
     /// ```
     /// #![feature(allocator_api)]
+    ///
     /// use std::rc::Rc;
     /// use std::alloc::System;
     ///

library/alloc/src/vec/extract_if.rs

@@ -130,20 +130,25 @@ where
     A: Allocator,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let peek = if self.idx < self.end {
-            // This has to use pointer arithmetic as `self.vec[self.idx]` or
-            // `self.vec.get_unchecked(self.idx)` wouldn't work since we
-            // temporarily set the length of `self.vec` to zero.
-            //
-            // SAFETY:
-            // Since `self.idx` is smaller than `self.end` and `self.end` is
-            // smaller than `self.old_len`, `idx` is valid for indexing the
-            // buffer. Also, per the invariant of `self.idx`, this element
-            // has not been inspected/moved out yet.
-            Some(unsafe { &*self.vec.as_ptr().add(self.idx) })
-        } else {
-            None
-        };
-        f.debug_struct("ExtractIf").field("peek", &peek).finish_non_exhaustive()
+        // We have to use pointer arithmetics here,
+        // because the length of `self.vec` is temporarily set to 0.
+        let start = self.vec.as_ptr();
+
+        // SAFETY: we always keep first `self.idx - self.del` elements valid.
+        let retained = unsafe { slice::from_raw_parts(start, self.idx - self.del) };
+
+        // SAFETY: we have not yet touched elements starting at `self.idx`.
+        let valid_tail =
+            unsafe { slice::from_raw_parts(start.add(self.idx), self.old_len - self.idx) };
+
+        // SAFETY: `end - idx <= old_len - idx`, because `end <= old_len`. Also `idx <= end` by invariant.
+        let (remainder, skipped_tail) =
+            unsafe { valid_tail.split_at_unchecked(self.end - self.idx) };
+
+        f.debug_struct("ExtractIf")
+            .field("retained", &retained)
+            .field("remainder", &remainder)
+            .field("skipped_tail", &skipped_tail)
+            .finish_non_exhaustive()
     }
 }

library/alloc/src/vec/mod.rs

@@ -1062,8 +1062,7 @@ impl<T, A: Allocator> Vec<T, A> {
     ///
     /// use std::alloc::System;
     ///
-    /// # #[allow(unused_mut)]
-    /// let mut vec: Vec<i32, _> = Vec::new_in(System);
+    /// let vec: Vec<i32, System> = Vec::new_in(System);
     /// ```
     #[inline]
     #[unstable(feature = "allocator_api", issue = "32838")]

library/alloctests/tests/vec.rs

@@ -1651,13 +1651,17 @@ fn extract_if_unconsumed() {
 
 #[test]
 fn extract_if_debug() {
-    let mut vec = vec![1, 2];
-    let mut drain = vec.extract_if(.., |&mut x| x % 2 != 0);
-    assert!(format!("{drain:?}").contains("Some(1)"));
-    drain.next();
-    assert!(format!("{drain:?}").contains("Some(2)"));
-    drain.next();
-    assert!(format!("{drain:?}").contains("None"));
+    let mut vec = vec![1, 2, 3, 4, 5, 6, 7, 8];
+    let mut drain = vec.extract_if(1..5, |&mut x| x % 2 != 0);
+    assert_eq!(
+        format!("{drain:?}"),
+        "ExtractIf { retained: [1], remainder: [2, 3, 4, 5], skipped_tail: [6, 7, 8], .. }"
+    );
+    drain.next().unwrap();
+    assert_eq!(
+        format!("{drain:?}"),
+        "ExtractIf { retained: [1, 2], remainder: [4, 5], skipped_tail: [6, 7, 8], .. }"
+    );
 }
 
 #[test]

library/coretests/tests/num/floats.rs

@@ -2,6 +2,9 @@ use std::hint::black_box;
 use std::num::FpCategory as Fp;
 use std::ops::{Add, Div, Mul, Rem, Sub};
 
+/// i586 has issues with floating point precision.
+const I586: bool = cfg!(target_arch = "x86") && cfg!(not(target_feature = "sse2"));
+
 pub(crate) trait TestableFloat: Sized {
     const BITS: u32;
     /// Unsigned int with the same size, for converting to/from bits.
@@ -59,6 +62,7 @@ pub(crate) trait TestableFloat: Sized {
     const NEG_MUL_ADD_RESULT: Self;
     /// Reciprocal of the maximum val
     const MAX_RECIP: Self;
+    const ASINH_ACOSH_MAX: Self;
 }
 
 impl TestableFloat for f16 {
@@ -103,6 +107,7 @@ impl TestableFloat for f16 {
     const MUL_ADD_RESULT: Self = 62.031;
     const NEG_MUL_ADD_RESULT: Self = 48.625;
     const MAX_RECIP: Self = 1.526624e-5;
+    const ASINH_ACOSH_MAX: Self = 11.781;
 }
 
 impl TestableFloat for f32 {
@@ -120,8 +125,20 @@ impl TestableFloat for f32 {
     const LOG_APPROX: Self = if cfg!(miri) { 1e-3 } else { Self::APPROX };
     const LOG2_APPROX: Self = if cfg!(miri) { 1e-3 } else { Self::APPROX };
     const LOG10_APPROX: Self = if cfg!(miri) { 1e-3 } else { Self::APPROX };
-    const ASINH_APPROX: Self = if cfg!(miri) { 1e-3 } else { Self::APPROX };
-    const ACOSH_APPROX: Self = if cfg!(miri) { 1e-3 } else { Self::APPROX };
+    const ASINH_APPROX: Self = if cfg!(miri) {
+        1e-3
+    } else if I586 {
+        1e-5
+    } else {
+        Self::APPROX
+    };
+    const ACOSH_APPROX: Self = if cfg!(miri) {
+        1e-3
+    } else if I586 {
+        1e-5
+    } else {
+        Self::APPROX
+    };
     const ATANH_APPROX: Self = if cfg!(miri) { 1e-3 } else { Self::APPROX };
     const GAMMA_APPROX: Self = if cfg!(miri) { 1e-3 } else { Self::APPROX };
     const GAMMA_APPROX_LOOSE: Self = if cfg!(miri) { 1e-2 } else { 1e-4 };
@@ -149,6 +166,7 @@ impl TestableFloat for f32 {
     const MUL_ADD_RESULT: Self = 62.05;
     const NEG_MUL_ADD_RESULT: Self = 48.65;
     const MAX_RECIP: Self = 2.938736e-39;
+    const ASINH_ACOSH_MAX: Self = 89.4159851;
 }
 
 impl TestableFloat for f64 {
@@ -180,6 +198,7 @@ impl TestableFloat for f64 {
     const MUL_ADD_RESULT: Self = 62.050000000000004;
     const NEG_MUL_ADD_RESULT: Self = 48.650000000000006;
     const MAX_RECIP: Self = 5.562684646268003e-309;
+    const ASINH_ACOSH_MAX: Self = 710.47586007394398;
 }
 
 impl TestableFloat for f128 {
@@ -221,6 +240,7 @@ impl TestableFloat for f128 {
     const MUL_ADD_RESULT: Self = 62.0500000000000000000000000000000037;
     const NEG_MUL_ADD_RESULT: Self = 48.6500000000000000000000000000000049;
     const MAX_RECIP: Self = 8.40525785778023376565669454330438228902076605e-4933;
+    const ASINH_ACOSH_MAX: Self = 11357.216553474703894801348310092223;
 }
 
 /// Determine the tolerance for values of the argument type.
@@ -1705,6 +1725,9 @@ float_test! {
 
         assert_approx_eq!(flt(-200.0).asinh(), -5.991470797049389, Float::ASINH_APPROX);
 
+        // issue 153878: large values were rounding to infinity
+        assert_approx_eq!(Float::MAX.asinh(), Float::ASINH_ACOSH_MAX, Float::ASINH_APPROX);
+
         #[allow(overflowing_literals)]
         if Float::MAX > flt(66000.0) {
              // regression test for the catastrophic cancellation fixed in 72486
@@ -1733,6 +1756,9 @@ float_test! {
         assert_approx_eq!(flt(2.0).acosh(), 1.31695789692481670862504634730796844, Float::ACOSH_APPROX);
         assert_approx_eq!(flt(3.0).acosh(), 1.76274717403908605046521864995958461, Float::ACOSH_APPROX);
 
+        // issue 153878: large values were rounding to infinity
+        assert_approx_eq!(Float::MAX.acosh(), Float::ASINH_ACOSH_MAX, Float::ACOSH_APPROX);
+
         #[allow(overflowing_literals)]
         if Float::MAX > flt(66000.0) {
             // test for low accuracy from issue 104548

library/std/src/collections/hash/map.rs

@@ -301,8 +301,11 @@ impl<K, V, A: Allocator> HashMap<K, V, RandomState, A> {
     /// # Examples
     ///
     /// ```
+    /// # #![feature(allocator_api)]
     /// use std::collections::HashMap;
-    /// let mut map: HashMap<&str, i32> = HashMap::new();
+    /// use std::alloc::Global;
+    ///
+    /// let map: HashMap<i32, i32> = HashMap::new_in(Global);
     /// ```
     #[inline]
     #[must_use]
@@ -321,8 +324,11 @@ impl<K, V, A: Allocator> HashMap<K, V, RandomState, A> {
     /// # Examples
     ///
     /// ```
+    /// # #![feature(allocator_api)]
     /// use std::collections::HashMap;
-    /// let mut map: HashMap<&str, i32> = HashMap::with_capacity(10);
+    /// use std::alloc::Global;
+    ///
+    /// let map: HashMap<i32, i32> = HashMap::with_capacity_in(10, Global);
     /// ```
     #[inline]
     #[must_use]
@@ -410,6 +416,18 @@ impl<K, V, S, A: Allocator> HashMap<K, V, S, A> {
     ///
     /// The `hash_builder` passed should implement the [`BuildHasher`] trait for
     /// the `HashMap` to be useful, see its documentation for details.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(allocator_api)]
+    /// use std::alloc::Global;
+    /// use std::collections::HashMap;
+    /// use std::hash::RandomState;
+    ///
+    /// let s = RandomState::new();
+    /// let map: HashMap<i32, i32> = HashMap::with_hasher_in(s, Global);
+    /// ```
     #[inline]
     #[must_use]
     #[unstable(feature = "allocator_api", issue = "32838")]
@@ -432,6 +450,17 @@ impl<K, V, S, A: Allocator> HashMap<K, V, S, A> {
     /// The `hasher` passed should implement the [`BuildHasher`] trait for
     /// the `HashMap` to be useful, see its documentation for details.
     ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(allocator_api)]
+    /// use std::alloc::Global;
+    /// use std::collections::HashMap;
+    /// use std::hash::RandomState;
+    ///
+    /// let s = RandomState::new();
+    /// let map: HashMap<i32, i32> = HashMap::with_capacity_and_hasher_in(10, s, Global);
+    /// ```
     #[inline]
     #[must_use]
     #[unstable(feature = "allocator_api", issue = "32838")]