Auto merge of rust-lang#155911 - jhpratt:rollup-DOR0YN1, r=jhpratt

Rollup of 9 pull requests

Successful merges:

 - rust-lang#155381 (Fix a bug in `ChunkedBitSet::subtract`)
 - rust-lang#155847 (Don't reload length in String::push)
 - rust-lang#155858 (`slice::join`: borrow only once during length calc)
 - rust-lang#155879 (enable pipe tests in Miri)
 - rust-lang#155905 (Update LLVM to 22.1.4 (again))
 - rust-lang#155247 ([AIX] update linker default to bcdtors)
 - rust-lang#155812 ([codex] tests: mark migrated UI tests as check-pass)
 - rust-lang#155854 (Rename the diagnostic item for `std::sync::mpsc::Receiver`)
 - rust-lang#155882 (Add regression test for rust-lang#101363)

Author: bors

compiler/rustc_index/src/bit_set.rs

@@ -833,13 +833,16 @@ impl<T: Idx> BitRelations<ChunkedBitSet<T>> for ChunkedBitSet<T> {
                     changed = true;
                     let num_words = num_words(*chunk_domain_size as usize);
                     debug_assert!(num_words > 0 && num_words <= CHUNK_WORDS);
-                    let mut tail_mask =
-                        1 << (*chunk_domain_size - ((num_words - 1) * WORD_BITS) as u16) - 1;
+                    // Set `self_chunk_words` to `other_chunk_words`, then invert all bits and
+                    // clear any excess bits in the final word.
                     let mut self_chunk_words = **other_chunk_words;
-                    for word in self_chunk_words[0..num_words].iter_mut().rev() {
-                        *word = !*word & tail_mask;
-                        tail_mask = Word::MAX;
+                    for word in self_chunk_words[0..num_words].iter_mut() {
+                        *word = !*word;
                     }
+                    clear_excess_bits_in_final_word(
+                        *chunk_domain_size as usize,
+                        &mut self_chunk_words[..num_words],
+                    );
                     let self_chunk_ones_count = *chunk_domain_size - *other_chunk_ones_count;
                     debug_assert_eq!(
                         self_chunk_ones_count,

compiler/rustc_index/src/bit_set/tests.rs

@@ -333,6 +333,33 @@ fn chunked_bitset() {
     assert_eq!(b10000.count(), 6000);
     b10000.assert_valid();
     b10000b.assert_valid();
+
+    //-----------------------------------------------------------------------
+
+    let mut b64 = ChunkedBitSet::<usize>::new_filled(64);
+
+    let mut b64b = ChunkedBitSet::<usize>::new_empty(64);
+    b64b.insert(0);
+
+    b64.subtract(&b64b);
+    assert!(!b64.contains(0));
+    assert!(b64.contains(10));
+    assert!(b64.contains(50));
+    assert!(b64.contains(63));
+    assert_eq!(
+        b64.chunks(),
+        #[rustfmt::skip]
+        vec![
+            Mixed {
+                chunk_domain_size: 64,
+                ones_count: 63,
+                words: Rc::new([
+                    0xfffffffffffffffe, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                ])
+            },
+        ],
+    );
 }
 
 fn with_elements_chunked(elements: &[usize], domain_size: usize) -> ChunkedBitSet<usize> {

compiler/rustc_target/src/spec/targets/powerpc64_ibm_aix.rs

@@ -5,7 +5,7 @@ pub(crate) fn target() -> Target {
     base.max_atomic_width = Some(64);
     base.add_pre_link_args(
         LinkerFlavor::Unix(Cc::No),
-        &["-b64", "-bpT:0x100000000", "-bpD:0x110000000", "-bcdtors:all:0:s"],
+        &["-b64", "-bpT:0x100000000", "-bpD:0x110000000", "-bcdtors:mbr:0:s"],
     );
 
     Target {

library/alloc/src/str.rs

@@ -135,13 +135,9 @@ macro_rules! copy_slice_and_advance {
 //
 // This implementation calls `borrow()` multiple times:
 // 1. To calculate `reserved_len`, all elements are borrowed once.
-// 2. The first element is borrowed again when copied via `extend_from_slice`.
-// 3. Subsequent elements are borrowed a second time when building the mapped iterator.
+// 2. All elements, except the first, are borrowed a second time when building the mapped iterator.
 //
 // Risks and Mitigations:
-// - If the first element GROWS on the second borrow, the length subtraction underflows.
-//   We mitigate this by doing a `checked_sub` to panic rather than allowing an underflow
-//   that fabricates a huge destination slice.
 // - If elements 2..N GROW on their second borrow, the target slice bounds set by `checked_sub`
 //   means that `split_at_mut` inside `copy_slice_and_advance!` will correctly panic.
 // - If elements SHRINK on their second borrow, the spare space is never written, and the final
@@ -157,8 +153,10 @@ where
     let mut iter = slice.iter();
 
     // the first slice is the only one without a separator preceding it
+    // we take care to only borrow this once during the length calculation
+    // to avoid inconsistent Borrow implementations from breaking our assumptions
     let first = match iter.next() {
-        Some(first) => first,
+        Some(first) => first.borrow().as_ref(),
         None => return vec![],
     };
 
@@ -168,21 +166,24 @@ where
     // the entire Vec pre-allocated for safety
     let reserved_len = sep_len
         .checked_mul(iter.len())
+        .and_then(|n| n.checked_add(first.len()))
         .and_then(|n| {
-            slice.iter().map(|s| s.borrow().as_ref().len()).try_fold(n, usize::checked_add)
+            // iter starts from the second element as we've already taken the first
+            // it's cloned so we can reuse the same iterator below
+            iter.clone().map(|s| s.borrow().as_ref().len()).try_fold(n, usize::checked_add)
         })
         .expect("attempt to join into collection with len > usize::MAX");
 
     // prepare an uninitialized buffer
     let mut result = Vec::with_capacity(reserved_len);
     debug_assert!(result.capacity() >= reserved_len);
 
-    result.extend_from_slice(first.borrow().as_ref());
+    result.extend_from_slice(first);
 
     unsafe {
         let pos = result.len();
-        let target_len = reserved_len.checked_sub(pos).expect("inconsistent Borrow implementation");
-        let target = result.spare_capacity_mut().get_unchecked_mut(..target_len);
+        debug_assert!(reserved_len >= pos);
+        let target = result.spare_capacity_mut().get_unchecked_mut(..reserved_len - pos);
 
         // Convert the separator and slices to slices of MaybeUninit
         // to simplify implementation in specialize_for_lengths.

library/alloc/src/string.rs

@@ -1420,7 +1420,7 @@ impl String {
 
         // SAFETY: Just reserved capacity for at least the length needed to encode `ch`.
         unsafe {
-            core::char::encode_utf8_raw_unchecked(ch as u32, self.vec.as_mut_ptr().add(self.len()));
+            core::char::encode_utf8_raw_unchecked(ch as u32, self.vec.as_mut_ptr().add(len));
             self.vec.set_len(len + ch_len);
         }
     }

library/alloctests/tests/str.rs

@@ -164,7 +164,7 @@ fn test_join_for_different_lengths_with_long_separator() {
 }
 
 #[test]
-fn test_join_issue_80335() {
+fn test_join_inconsistent_borrow_shrink() {
     use core::borrow::Borrow;
     use core::cell::Cell;
 
@@ -191,12 +191,12 @@ fn test_join_issue_80335() {
     }
 
     let arr: [WeirdBorrow; 3] = Default::default();
-    test_join!("0-0-0", arr, "-");
+    test_join!("123456-0-0", arr, "-");
 }
 
 #[test]
-#[should_panic(expected = "inconsistent Borrow implementation")]
-fn test_join_inconsistent_borrow() {
+#[should_panic(expected = "mid > len")]
+fn test_join_inconsistent_borrow_grow() {
     use std::borrow::Borrow;
     use std::cell::Cell;
 

library/std/src/io/pipe.rs

@@ -40,8 +40,6 @@ use crate::sys::{FromInner, IntoInner, pipe as imp};
 /// # Example
 ///
 /// ```no_run
-/// # #[cfg(miri)] fn main() {}
-/// # #[cfg(not(miri))]
 /// # fn main() -> std::io::Result<()> {
 /// use std::io::{Read, Write, pipe};
 /// use std::process::Command;
@@ -126,8 +124,6 @@ impl PipeReader {
     /// # Examples
     ///
     /// ```no_run
-    /// # #[cfg(miri)] fn main() {}
-    /// # #[cfg(not(miri))]
     /// # fn main() -> std::io::Result<()> {
     /// use std::fs;
     /// use std::io::{pipe, Write};
@@ -185,8 +181,6 @@ impl PipeWriter {
     /// # Examples
     ///
     /// ```no_run
-    /// # #[cfg(miri)] fn main() {}
-    /// # #[cfg(not(miri))]
     /// # fn main() -> std::io::Result<()> {
     /// use std::process::Command;
     /// use std::io::{pipe, Read};

library/std/src/io/pipe/tests.rs

@@ -1,7 +1,6 @@
 use crate::io::{Read, Write, pipe};
 
 #[test]
-#[cfg(all(any(unix, windows), not(miri)))]
 fn pipe_creation_clone_and_rw() {
     let (rx, tx) = pipe().unwrap();
 

library/std/src/sync/mpmc/mod.rs

@@ -297,6 +297,7 @@ pub fn sync_channel<T>(cap: usize) -> (Sender<T>, Receiver<T>) {
 /// assert_eq!(3, msg + msg2);
 /// ```
 #[unstable(feature = "mpmc_channel", issue = "126840")]
+#[cfg_attr(not(test), rustc_diagnostic_item = "MpmcSender")]
 pub struct Sender<T> {
     flavor: SenderFlavor<T>,
 }
@@ -722,6 +723,7 @@ impl<T> fmt::Debug for Sender<T> {
 /// rx_thread_2.join().unwrap();
 /// ```
 #[unstable(feature = "mpmc_channel", issue = "126840")]
+#[cfg_attr(not(test), rustc_diagnostic_item = "MpmcReceiver")]
 pub struct Receiver<T> {
     flavor: ReceiverFlavor<T>,
 }

library/std/src/sync/mpsc.rs

@@ -173,7 +173,7 @@ use crate::{error, fmt};
 /// println!("{}", recv.recv().unwrap()); // Received after 2 seconds
 /// ```
 #[stable(feature = "rust1", since = "1.0.0")]
-#[cfg_attr(not(test), rustc_diagnostic_item = "Receiver")]
+#[cfg_attr(not(test), rustc_diagnostic_item = "MpscReceiver")]
 pub struct Receiver<T> {
     inner: mpmc::Receiver<T>,
 }