From c0e913fdd7f35b197c6da198c25569fc63244b85 Mon Sep 17 00:00:00 2001
From: Noa <coolreader18@gmail.com>
Date: Fri, 8 Mar 2024 12:27:24 -0600
Subject: [PATCH 01/17] Document overrides of `clone_from()`

Specifically, when an override doesn't just forward to an inner type,
document the behavior and that it's preferred over simply assigning
a clone of source. Also, change instances where the second parameter is
"other" to "source".
---
 library/alloc/src/boxed.rs                    | 26 +++++++++++---
 .../alloc/src/collections/binary_heap/mod.rs  |  6 ++++
 library/alloc/src/collections/btree/set.rs    |  4 +--
 library/alloc/src/collections/linked_list.rs  | 22 +++++++-----
 .../alloc/src/collections/vec_deque/mod.rs    | 10 ++++--
 library/alloc/src/string.rs                   |  4 +++
 library/alloc/src/vec/mod.rs                  | 26 ++++++++++++--
 library/core/src/cell.rs                      |  4 +--
 library/core/src/cmp.rs                       |  4 +--
 library/core/src/task/wake.rs                 | 36 +++++++++++++++++++
 library/std/src/collections/hash/map.rs       |  4 +--
 library/std/src/collections/hash/set.rs       |  4 +++
 library/std/src/ffi/os_str.rs                 |  4 +++
 library/std/src/path.rs                       |  4 +++
 14 files changed, 134 insertions(+), 24 deletions(-)

diff --git a/library/alloc/src/boxed.rs b/library/alloc/src/boxed.rs
index 2736e5ee6c58..91247e7ad4c2 100644
--- a/library/alloc/src/boxed.rs
+++ b/library/alloc/src/boxed.rs
@@ -2084,11 +2084,29 @@ impl<T: Clone, A: Allocator + Clone> Clone for Box<[T], A> {
         self.to_vec_in(alloc).into_boxed_slice()
     }
 
-    fn clone_from(&mut self, other: &Self) {
-        if self.len() == other.len() {
-            self.clone_from_slice(&other);
+    /// Copies `source`'s contents into `self` without creating a new allocation,
+    /// so long as the two are of the same length.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// let x = Box::new([5, 6, 7]);
+    /// let mut y = Box::new([8, 9, 10]);
+    /// let yp: *const [i32] = &*y;
+    ///
+    /// y.clone_from(&x);
+    ///
+    /// // The value is the same
+    /// assert_eq!(x, y);
+    ///
+    /// // And no allocation occurred
+    /// assert_eq!(yp, &*y);
+    /// ```
+    fn clone_from(&mut self, source: &Self) {
+        if self.len() == source.len() {
+            self.clone_from_slice(&source);
         } else {
-            *self = other.clone();
+            *self = source.clone();
         }
     }
 }
diff --git a/library/alloc/src/collections/binary_heap/mod.rs b/library/alloc/src/collections/binary_heap/mod.rs
index 83b2678f7f52..c54f0062824a 100644
--- a/library/alloc/src/collections/binary_heap/mod.rs
+++ b/library/alloc/src/collections/binary_heap/mod.rs
@@ -385,6 +385,12 @@ impl<T: Clone, A: Allocator + Clone> Clone for BinaryHeap<T, A> {
         BinaryHeap { data: self.data.clone() }
     }
 
+    /// Overwrites the contents of `self` with a clone of the contents of `source`.
+    ///
+    /// This method is preferred over simply assigning `source.clone()` to `self`,
+    /// as it avoids reallocation if possible.
+    ///
+    /// See [`Vec::clone_from()`] for more details.
     fn clone_from(&mut self, source: &Self) {
         self.data.clone_from(&source.data);
     }
diff --git a/library/alloc/src/collections/btree/set.rs b/library/alloc/src/collections/btree/set.rs
index ed91ae1a66e3..2d42de4747cb 100644
--- a/library/alloc/src/collections/btree/set.rs
+++ b/library/alloc/src/collections/btree/set.rs
@@ -116,8 +116,8 @@ impl<T: Clone, A: Allocator + Clone> Clone for BTreeSet<T, A> {
         BTreeSet { map: self.map.clone() }
     }
 
-    fn clone_from(&mut self, other: &Self) {
-        self.map.clone_from(&other.map);
+    fn clone_from(&mut self, source: &Self) {
+        self.map.clone_from(&source.map);
     }
 }
 
diff --git a/library/alloc/src/collections/linked_list.rs b/library/alloc/src/collections/linked_list.rs
index 6dfb82ac807a..1c90c171a155 100644
--- a/library/alloc/src/collections/linked_list.rs
+++ b/library/alloc/src/collections/linked_list.rs
@@ -2126,16 +2126,22 @@ impl<T: Clone, A: Allocator + Clone> Clone for LinkedList<T, A> {
         list
     }
 
-    fn clone_from(&mut self, other: &Self) {
-        let mut iter_other = other.iter();
-        if self.len() > other.len() {
-            self.split_off(other.len());
+    /// Overwrites the contents of `self` with a clone of the contents of `source`.
+    ///
+    /// This method is preferred over simply assigning `source.clone()` to `self`,
+    /// as it avoids reallocation of the nodes of the linked list. Additionally,
+    /// if the element type `T` overrides `clone_from()`, this will reuse the
+    /// resources of `self`'s elements as well.
+    fn clone_from(&mut self, source: &Self) {
+        let mut source_iter = source.iter();
+        if self.len() > source.len() {
+            self.split_off(source.len());
         }
-        for (elem, elem_other) in self.iter_mut().zip(&mut iter_other) {
-            elem.clone_from(elem_other);
+        for (elem, source_elem) in self.iter_mut().zip(&mut source_iter) {
+            elem.clone_from(source_elem);
         }
-        if !iter_other.is_empty() {
-            self.extend(iter_other.cloned());
+        if !source_iter.is_empty() {
+            self.extend(source_iter.cloned());
         }
     }
 }
diff --git a/library/alloc/src/collections/vec_deque/mod.rs b/library/alloc/src/collections/vec_deque/mod.rs
index c35bab5ef665..8df7ca3411d6 100644
--- a/library/alloc/src/collections/vec_deque/mod.rs
+++ b/library/alloc/src/collections/vec_deque/mod.rs
@@ -113,9 +113,15 @@ impl<T: Clone, A: Allocator + Clone> Clone for VecDeque<T, A> {
         deq
     }
 
-    fn clone_from(&mut self, other: &Self) {
+    /// Overwrites the contents of `self` with a clone of the contents of `source`.
+    ///
+    /// This method is preferred over simply assigning `source.clone()` to `self`,
+    /// as it avoids reallocation if possible. Additionally, if the element type
+    /// `T` overrides `clone_from()`, this will reuse the resources of `self`'s
+    /// elements as well.
+    fn clone_from(&mut self, source: &Self) {
         self.clear();
-        self.extend(other.iter().cloned());
+        self.extend(source.iter().cloned());
     }
 }
 
diff --git a/library/alloc/src/string.rs b/library/alloc/src/string.rs
index 98ded7f6cdf5..fd36583ec8e8 100644
--- a/library/alloc/src/string.rs
+++ b/library/alloc/src/string.rs
@@ -2084,6 +2084,10 @@ impl Clone for String {
         String { vec: self.vec.clone() }
     }
 
+    /// Clones the contents of `source` into `self`.
+    ///
+    /// This method is preferred over simply assigning `source.clone()` to `self`,
+    /// as it avoids reallocation if possible.
     fn clone_from(&mut self, source: &Self) {
         self.vec.clone_from(&source.vec);
     }
diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs
index c0e934b3b1fc..b8ed9710839a 100644
--- a/library/alloc/src/vec/mod.rs
+++ b/library/alloc/src/vec/mod.rs
@@ -2758,8 +2758,30 @@ impl<T: Clone, A: Allocator + Clone> Clone for Vec<T, A> {
         crate::slice::to_vec(&**self, alloc)
     }
 
-    fn clone_from(&mut self, other: &Self) {
-        crate::slice::SpecCloneIntoVec::clone_into(other.as_slice(), self);
+    /// Overwrites the contents of `self` with a clone of the contents of `source`.
+    ///
+    /// This method is preferred over simply assigning `source.clone()` to `self`,
+    /// as it avoids reallocation if possible. Additionally, if the element type
+    /// `T` overrides `clone_from()`, this will reuse the resources of `self`'s
+    /// elements as well.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// let x = vec![5, 6, 7];
+    /// let mut y = vec![8, 9, 10];
+    /// let yp: *const i32 = y.as_ptr();
+    ///
+    /// y.clone_from(&x);
+    ///
+    /// // The value is the same
+    /// assert_eq!(x, y);
+    ///
+    /// // And no reallocation occurred
+    /// assert_eq!(yp, y.as_ptr());
+    /// ```
+    fn clone_from(&mut self, source: &Self) {
+        crate::slice::SpecCloneIntoVec::clone_into(source.as_slice(), self);
     }
 }
 
diff --git a/library/core/src/cell.rs b/library/core/src/cell.rs
index 19b05448c878..835edc4424d8 100644
--- a/library/core/src/cell.rs
+++ b/library/core/src/cell.rs
@@ -1276,8 +1276,8 @@ impl<T: Clone> Clone for RefCell<T> {
     /// Panics if `other` is currently mutably borrowed.
     #[inline]
     #[track_caller]
-    fn clone_from(&mut self, other: &Self) {
-        self.get_mut().clone_from(&other.borrow())
+    fn clone_from(&mut self, source: &Self) {
+        self.get_mut().clone_from(&source.borrow())
     }
 }
 
diff --git a/library/core/src/cmp.rs b/library/core/src/cmp.rs
index a2f07814726a..500fd5ef5c3a 100644
--- a/library/core/src/cmp.rs
+++ b/library/core/src/cmp.rs
@@ -684,8 +684,8 @@ impl<T: Clone> Clone for Reverse<T> {
     }
 
     #[inline]
-    fn clone_from(&mut self, other: &Self) {
-        self.0.clone_from(&other.0)
+    fn clone_from(&mut self, source: &Self) {
+        self.0.clone_from(&source.0)
     }
 }
 
diff --git a/library/core/src/task/wake.rs b/library/core/src/task/wake.rs
index 8fc942dedc9b..7ce9693576e7 100644
--- a/library/core/src/task/wake.rs
+++ b/library/core/src/task/wake.rs
@@ -515,6 +515,42 @@ impl Clone for Waker {
         }
     }
 
+    /// Assigns a clone of `source` to `self`, unless [`self.will_wake(source)`][Waker::will_wake] anyway.
+    ///
+    /// This method is preferred over simply assigning `source.clone()` to `self`,
+    /// as it avoids cloning the waker if `self` is already the same waker.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::future::Future;
+    /// use std::pin::Pin;
+    /// use std::sync::{Arc, Mutex};
+    /// use std::task::{Context, Poll, Waker};
+    ///
+    /// struct Waiter {
+    ///     shared: Arc<Mutex<Shared>>,
+    /// }
+    ///
+    /// struct Shared {
+    ///     waker: Waker,
+    ///     // ...
+    /// }
+    ///
+    /// impl Future for Waiter {
+    ///     type Output = ();
+    ///     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
+    ///         let mut shared = self.shared.lock().unwrap();
+    ///
+    ///         // update the waker
+    ///         shared.waker.clone_from(cx.waker());
+    ///
+    ///         // readiness logic ...
+    /// #       Poll::Ready(())
+    ///     }
+    /// }
+    ///
+    /// ```
     #[inline]
     fn clone_from(&mut self, source: &Self) {
         if !self.will_wake(source) {
diff --git a/library/std/src/collections/hash/map.rs b/library/std/src/collections/hash/map.rs
index 627befb63a1b..7ec4d4829e5b 100644
--- a/library/std/src/collections/hash/map.rs
+++ b/library/std/src/collections/hash/map.rs
@@ -1271,8 +1271,8 @@ where
     }
 
     #[inline]
-    fn clone_from(&mut self, other: &Self) {
-        self.base.clone_from(&other.base);
+    fn clone_from(&mut self, source: &Self) {
+        self.base.clone_from(&source.base);
     }
 }
 
diff --git a/library/std/src/collections/hash/set.rs b/library/std/src/collections/hash/set.rs
index 371201ff44cb..fffbfe477e2b 100644
--- a/library/std/src/collections/hash/set.rs
+++ b/library/std/src/collections/hash/set.rs
@@ -978,6 +978,10 @@ where
         Self { base: self.base.clone() }
     }
 
+    /// Overwrites the contents of `self` with a clone of the contents of `source`.
+    ///
+    /// This method is preferred over simply assigning `source.clone()` to `self`,
+    /// as it avoids reallocation if possible.
     #[inline]
     fn clone_from(&mut self, other: &Self) {
         self.base.clone_from(&other.base);
diff --git a/library/std/src/ffi/os_str.rs b/library/std/src/ffi/os_str.rs
index e44da8e637e9..ef7976d2c501 100644
--- a/library/std/src/ffi/os_str.rs
+++ b/library/std/src/ffi/os_str.rs
@@ -606,6 +606,10 @@ impl Clone for OsString {
         OsString { inner: self.inner.clone() }
     }
 
+    /// Clones the contents of `source` into `self`.
+    ///
+    /// This method is preferred over simply assigning `source.clone()` to `self`,
+    /// as it avoids reallocation if possible.
     #[inline]
     fn clone_from(&mut self, source: &Self) {
         self.inner.clone_from(&source.inner)
diff --git a/library/std/src/path.rs b/library/std/src/path.rs
index 56ea51226f9d..51cbb1a0f12e 100644
--- a/library/std/src/path.rs
+++ b/library/std/src/path.rs
@@ -1628,6 +1628,10 @@ impl Clone for PathBuf {
         PathBuf { inner: self.inner.clone() }
     }
 
+    /// Clones the contents of `source` into `self`.
+    ///
+    /// This method is preferred over simply assigning `source.clone()` to `self`,
+    /// as it avoids reallocation if possible.
     #[inline]
     fn clone_from(&mut self, source: &Self) {
         self.inner.clone_from(&source.inner)

From c8f6e03c1570200dbb99587fb257d371aa7447b3 Mon Sep 17 00:00:00 2001
From: Oli Scherer <git-spam-no-reply9815368754983@oli-obk.de>
Date: Tue, 9 Apr 2024 10:19:48 +0000
Subject: [PATCH 02/17] Add regression test

---
 tests/ui/wf/conflicting-impls.rs     | 22 +++++++++++++++
 tests/ui/wf/conflicting-impls.stderr | 41 ++++++++++++++++++++++++++++
 2 files changed, 63 insertions(+)
 create mode 100644 tests/ui/wf/conflicting-impls.rs
 create mode 100644 tests/ui/wf/conflicting-impls.stderr

diff --git a/tests/ui/wf/conflicting-impls.rs b/tests/ui/wf/conflicting-impls.rs
new file mode 100644
index 000000000000..c387199a8bf1
--- /dev/null
+++ b/tests/ui/wf/conflicting-impls.rs
@@ -0,0 +1,22 @@
+//@ edition: 2021
+
+struct Ty;
+
+impl TryFrom<Ty> for u8 {
+    type Error = Ty;
+    fn try_from(_: Ty) -> Result<Self, Self::Error> {
+        //~^ ERROR type annotations needed
+        loop {}
+    }
+}
+
+impl TryFrom<Ty> for u8 {
+    //~^ ERROR conflicting implementations of trait
+    type Error = Ty;
+    fn try_from(_: Ty) -> Result<Self, Self::Error> {
+        //~^ ERROR type annotations needed
+        loop {}
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/wf/conflicting-impls.stderr b/tests/ui/wf/conflicting-impls.stderr
new file mode 100644
index 000000000000..69f48f69bfbf
--- /dev/null
+++ b/tests/ui/wf/conflicting-impls.stderr
@@ -0,0 +1,41 @@
+error[E0119]: conflicting implementations of trait `TryFrom<Ty>` for type `u8`
+  --> $DIR/conflicting-impls.rs:12:1
+   |
+LL | impl TryFrom<Ty> for u8 {
+   | ----------------------- first implementation here
+...
+LL | impl TryFrom<Ty> for u8 {
+   | ^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `u8`
+
+error[E0282]: type annotations needed
+  --> $DIR/conflicting-impls.rs:7:5
+   |
+LL |     fn try_from(_: Ty) -> Result<Self, Self::Error> {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot infer type
+   |
+note: the requirement `_ <: _` appears on the `impl`'s method `try_from` but not on the corresponding trait's method
+  --> $SRC_DIR/core/src/convert/mod.rs:LL:COL
+   |
+   = note: in this trait
+  ::: $SRC_DIR/core/src/convert/mod.rs:LL:COL
+   |
+   = note: this trait's method doesn't have the requirement `_ <: _`
+
+error[E0282]: type annotations needed
+  --> $DIR/conflicting-impls.rs:14:5
+   |
+LL |     fn try_from(_: Ty) -> Result<Self, Self::Error> {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot infer type
+   |
+note: the requirement `_ <: _` appears on the `impl`'s method `try_from` but not on the corresponding trait's method
+  --> $SRC_DIR/core/src/convert/mod.rs:LL:COL
+   |
+   = note: in this trait
+  ::: $SRC_DIR/core/src/convert/mod.rs:LL:COL
+   |
+   = note: this trait's method doesn't have the requirement `_ <: _`
+
+error: aborting due to 3 previous errors
+
+Some errors have detailed explanations: E0119, E0282.
+For more information about an error, try `rustc --explain E0119`.

From c0a9c8c9549662ec9199112cb59592ef2c617412 Mon Sep 17 00:00:00 2001
From: Oli Scherer <git-spam-no-reply9815368754983@oli-obk.de>
Date: Tue, 9 Apr 2024 10:23:58 +0000
Subject: [PATCH 03/17] Silence some follow-up errors on trait impls in case
 the trait has conflicting or otherwise incoherent impls

---
 .../rustc_hir_analysis/src/check/check.rs     | 10 ++++-
 ...t-conflicts-with-specific-multidispatch.rs |  3 +-
 ...nflicts-with-specific-multidispatch.stderr | 23 ++---------
 tests/ui/coherence/coherence-orphan.rs        |  3 --
 tests/ui/coherence/coherence-orphan.stderr    | 31 ++------------
 tests/ui/error-codes/E0117.rs                 |  1 -
 tests/ui/error-codes/E0117.stderr             | 14 ++-----
 tests/ui/issues/issue-67535.rs                |  6 +--
 tests/ui/issues/issue-67535.stderr            | 41 +------------------
 tests/ui/wf/conflicting-impls.rs              |  2 -
 tests/ui/wf/conflicting-impls.stderr          | 33 +--------------
 11 files changed, 25 insertions(+), 142 deletions(-)

diff --git a/compiler/rustc_hir_analysis/src/check/check.rs b/compiler/rustc_hir_analysis/src/check/check.rs
index 8d4ae10d4bfe..b223c590bff6 100644
--- a/compiler/rustc_hir_analysis/src/check/check.rs
+++ b/compiler/rustc_hir_analysis/src/check/check.rs
@@ -534,8 +534,14 @@ pub(crate) fn check_item_type(tcx: TyCtxt<'_>, def_id: LocalDefId) {
         }
         DefKind::Impl { of_trait } => {
             if of_trait && let Some(impl_trait_header) = tcx.impl_trait_header(def_id) {
-                check_impl_items_against_trait(tcx, def_id, impl_trait_header);
-                check_on_unimplemented(tcx, def_id);
+                if tcx
+                    .ensure()
+                    .coherent_trait(impl_trait_header.trait_ref.instantiate_identity().def_id)
+                    .is_ok()
+                {
+                    check_impl_items_against_trait(tcx, def_id, impl_trait_header);
+                    check_on_unimplemented(tcx, def_id);
+                }
             }
         }
         DefKind::Trait => {
diff --git a/tests/ui/coherence/coherence-blanket-conflicts-with-specific-multidispatch.rs b/tests/ui/coherence/coherence-blanket-conflicts-with-specific-multidispatch.rs
index 8426748fd52e..fd54fe2b0e8a 100644
--- a/tests/ui/coherence/coherence-blanket-conflicts-with-specific-multidispatch.rs
+++ b/tests/ui/coherence/coherence-blanket-conflicts-with-specific-multidispatch.rs
@@ -22,8 +22,7 @@ struct MyType {
 impl MyTrait<MyType> for MyType {
 //~^ ERROR E0119
     fn get(&self) -> usize { (*self).clone() }
-    //~^ ERROR incompatible type
-    //~| ERROR mismatched types
+    //~^ ERROR mismatched types
 }
 
 fn main() { }
diff --git a/tests/ui/coherence/coherence-blanket-conflicts-with-specific-multidispatch.stderr b/tests/ui/coherence/coherence-blanket-conflicts-with-specific-multidispatch.stderr
index 0653009409c5..fc6250dfa026 100644
--- a/tests/ui/coherence/coherence-blanket-conflicts-with-specific-multidispatch.stderr
+++ b/tests/ui/coherence/coherence-blanket-conflicts-with-specific-multidispatch.stderr
@@ -7,23 +7,6 @@ LL | impl<T> MyTrait<T> for T {
 LL | impl MyTrait<MyType> for MyType {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `MyType`
 
-error[E0053]: method `get` has an incompatible type for trait
-  --> $DIR/coherence-blanket-conflicts-with-specific-multidispatch.rs:24:22
-   |
-LL |     fn get(&self) -> usize { (*self).clone() }
-   |                      ^^^^^
-   |                      |
-   |                      expected `MyType`, found `usize`
-   |                      help: change the output type to match the trait: `MyType`
-   |
-note: type in trait
-  --> $DIR/coherence-blanket-conflicts-with-specific-multidispatch.rs:8:22
-   |
-LL |     fn get(&self) -> T;
-   |                      ^
-   = note: expected signature `fn(&MyType) -> MyType`
-              found signature `fn(&MyType) -> usize`
-
 error[E0308]: mismatched types
   --> $DIR/coherence-blanket-conflicts-with-specific-multidispatch.rs:24:30
    |
@@ -32,7 +15,7 @@ LL |     fn get(&self) -> usize { (*self).clone() }
    |                      |
    |                      expected `usize` because of return type
 
-error: aborting due to 3 previous errors
+error: aborting due to 2 previous errors
 
-Some errors have detailed explanations: E0053, E0119, E0308.
-For more information about an error, try `rustc --explain E0053`.
+Some errors have detailed explanations: E0119, E0308.
+For more information about an error, try `rustc --explain E0119`.
diff --git a/tests/ui/coherence/coherence-orphan.rs b/tests/ui/coherence/coherence-orphan.rs
index 9c96958f21a1..aee6647a7881 100644
--- a/tests/ui/coherence/coherence-orphan.rs
+++ b/tests/ui/coherence/coherence-orphan.rs
@@ -9,13 +9,10 @@ struct TheType;
 
 impl TheTrait<usize> for isize {}
 //~^ ERROR E0117
-//~| ERROR not all trait items implemented
 
 impl TheTrait<TheType> for isize {}
-//~^ ERROR not all trait items implemented
 
 impl TheTrait<isize> for TheType {}
-//~^ ERROR not all trait items implemented
 
 impl !Send for Vec<isize> {} //~ ERROR E0117
 
diff --git a/tests/ui/coherence/coherence-orphan.stderr b/tests/ui/coherence/coherence-orphan.stderr
index 48843f7cd181..f6ffae342908 100644
--- a/tests/ui/coherence/coherence-orphan.stderr
+++ b/tests/ui/coherence/coherence-orphan.stderr
@@ -10,32 +10,8 @@ LL | impl TheTrait<usize> for isize {}
    |
    = note: define and implement a trait or new type instead
 
-error[E0046]: not all trait items implemented, missing: `the_fn`
-  --> $DIR/coherence-orphan.rs:10:1
-   |
-LL | impl TheTrait<usize> for isize {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ missing `the_fn` in implementation
-   |
-   = help: implement the missing item: `fn the_fn(&self) { todo!() }`
-
-error[E0046]: not all trait items implemented, missing: `the_fn`
-  --> $DIR/coherence-orphan.rs:14:1
-   |
-LL | impl TheTrait<TheType> for isize {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ missing `the_fn` in implementation
-   |
-   = help: implement the missing item: `fn the_fn(&self) { todo!() }`
-
-error[E0046]: not all trait items implemented, missing: `the_fn`
-  --> $DIR/coherence-orphan.rs:17:1
-   |
-LL | impl TheTrait<isize> for TheType {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ missing `the_fn` in implementation
-   |
-   = help: implement the missing item: `fn the_fn(&self) { todo!() }`
-
 error[E0117]: only traits defined in the current crate can be implemented for types defined outside of the crate
-  --> $DIR/coherence-orphan.rs:20:1
+  --> $DIR/coherence-orphan.rs:17:1
    |
 LL | impl !Send for Vec<isize> {}
    | ^^^^^^^^^^^^^^^----------
@@ -45,7 +21,6 @@ LL | impl !Send for Vec<isize> {}
    |
    = note: define and implement a trait or new type instead
 
-error: aborting due to 5 previous errors
+error: aborting due to 2 previous errors
 
-Some errors have detailed explanations: E0046, E0117.
-For more information about an error, try `rustc --explain E0046`.
+For more information about this error, try `rustc --explain E0117`.
diff --git a/tests/ui/error-codes/E0117.rs b/tests/ui/error-codes/E0117.rs
index 32b9863806c0..406d24e36661 100644
--- a/tests/ui/error-codes/E0117.rs
+++ b/tests/ui/error-codes/E0117.rs
@@ -1,5 +1,4 @@
 impl Drop for u32 {} //~ ERROR E0117
 //~| ERROR the `Drop` trait may only be implemented for local structs, enums, and unions
-//~| ERROR not all trait items implemented
 
 fn main() {}
diff --git a/tests/ui/error-codes/E0117.stderr b/tests/ui/error-codes/E0117.stderr
index 058a64b20d17..f144aa9f72c1 100644
--- a/tests/ui/error-codes/E0117.stderr
+++ b/tests/ui/error-codes/E0117.stderr
@@ -15,15 +15,7 @@ error[E0120]: the `Drop` trait may only be implemented for local structs, enums,
 LL | impl Drop for u32 {}
    |               ^^^ must be a struct, enum, or union in the current crate
 
-error[E0046]: not all trait items implemented, missing: `drop`
-  --> $DIR/E0117.rs:1:1
-   |
-LL | impl Drop for u32 {}
-   | ^^^^^^^^^^^^^^^^^ missing `drop` in implementation
-   |
-   = help: implement the missing item: `fn drop(&mut self) { todo!() }`
+error: aborting due to 2 previous errors
 
-error: aborting due to 3 previous errors
-
-Some errors have detailed explanations: E0046, E0117, E0120.
-For more information about an error, try `rustc --explain E0046`.
+Some errors have detailed explanations: E0117, E0120.
+For more information about an error, try `rustc --explain E0117`.
diff --git a/tests/ui/issues/issue-67535.rs b/tests/ui/issues/issue-67535.rs
index 153b95a16743..24f50621310f 100644
--- a/tests/ui/issues/issue-67535.rs
+++ b/tests/ui/issues/issue-67535.rs
@@ -2,21 +2,21 @@ fn main() {}
 
 impl std::ops::AddAssign for () {
     //~^ ERROR only traits defined in the current crate can be implemented for arbitrary types
-    fn add_assign(&self, other: ()) -> () { //~ ERROR incompatible type
+    fn add_assign(&self, other: ()) -> () {
         ()
     }
 }
 
 impl std::ops::AddAssign for [(); 1] {
     //~^ ERROR only traits defined in the current crate can be implemented for arbitrary types
-    fn add_assign(&self, other: [(); 1]) -> [(); 1] { //~ ERROR incompatible type
+    fn add_assign(&self, other: [(); 1]) -> [(); 1] {
         [()]
     }
 }
 
 impl std::ops::AddAssign for &[u8] {
     //~^ ERROR only traits defined in the current crate can be implemented for arbitrary types
-    fn add_assign(&self, other: &[u8]) -> &[u8] { //~ ERROR incompatible type
+    fn add_assign(&self, other: &[u8]) -> &[u8] {
         self
     }
 }
diff --git a/tests/ui/issues/issue-67535.stderr b/tests/ui/issues/issue-67535.stderr
index c8bde2cb88c7..4d7a02a50969 100644
--- a/tests/ui/issues/issue-67535.stderr
+++ b/tests/ui/issues/issue-67535.stderr
@@ -34,43 +34,6 @@ LL | impl std::ops::AddAssign for &[u8] {
    |
    = note: define and implement a trait or new type instead
 
-error[E0053]: method `add_assign` has an incompatible type for trait
-  --> $DIR/issue-67535.rs:5:19
-   |
-LL |     fn add_assign(&self, other: ()) -> () {
-   |                   ^^^^^
-   |                   |
-   |                   types differ in mutability
-   |                   help: change the self-receiver type to match the trait: `&mut self`
-   |
-   = note: expected signature `fn(&mut (), ())`
-              found signature `fn(&(), ())`
+error: aborting due to 3 previous errors
 
-error[E0053]: method `add_assign` has an incompatible type for trait
-  --> $DIR/issue-67535.rs:12:19
-   |
-LL |     fn add_assign(&self, other: [(); 1]) -> [(); 1] {
-   |                   ^^^^^
-   |                   |
-   |                   types differ in mutability
-   |                   help: change the self-receiver type to match the trait: `&mut self`
-   |
-   = note: expected signature `fn(&mut _, _)`
-              found signature `fn(&_, _) -> [(); 1]`
-
-error[E0053]: method `add_assign` has an incompatible type for trait
-  --> $DIR/issue-67535.rs:19:19
-   |
-LL |     fn add_assign(&self, other: &[u8]) -> &[u8] {
-   |                   ^^^^^
-   |                   |
-   |                   types differ in mutability
-   |                   help: change the self-receiver type to match the trait: `&mut self`
-   |
-   = note: expected signature `fn(&mut &_, &_)`
-              found signature `fn(&&_, &_) -> &[u8]`
-
-error: aborting due to 6 previous errors
-
-Some errors have detailed explanations: E0053, E0117.
-For more information about an error, try `rustc --explain E0053`.
+For more information about this error, try `rustc --explain E0117`.
diff --git a/tests/ui/wf/conflicting-impls.rs b/tests/ui/wf/conflicting-impls.rs
index c387199a8bf1..8054eb7c5943 100644
--- a/tests/ui/wf/conflicting-impls.rs
+++ b/tests/ui/wf/conflicting-impls.rs
@@ -5,7 +5,6 @@ struct Ty;
 impl TryFrom<Ty> for u8 {
     type Error = Ty;
     fn try_from(_: Ty) -> Result<Self, Self::Error> {
-        //~^ ERROR type annotations needed
         loop {}
     }
 }
@@ -14,7 +13,6 @@ impl TryFrom<Ty> for u8 {
     //~^ ERROR conflicting implementations of trait
     type Error = Ty;
     fn try_from(_: Ty) -> Result<Self, Self::Error> {
-        //~^ ERROR type annotations needed
         loop {}
     }
 }
diff --git a/tests/ui/wf/conflicting-impls.stderr b/tests/ui/wf/conflicting-impls.stderr
index 69f48f69bfbf..d31ae17aa8f7 100644
--- a/tests/ui/wf/conflicting-impls.stderr
+++ b/tests/ui/wf/conflicting-impls.stderr
@@ -7,35 +7,6 @@ LL | impl TryFrom<Ty> for u8 {
 LL | impl TryFrom<Ty> for u8 {
    | ^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `u8`
 
-error[E0282]: type annotations needed
-  --> $DIR/conflicting-impls.rs:7:5
-   |
-LL |     fn try_from(_: Ty) -> Result<Self, Self::Error> {
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot infer type
-   |
-note: the requirement `_ <: _` appears on the `impl`'s method `try_from` but not on the corresponding trait's method
-  --> $SRC_DIR/core/src/convert/mod.rs:LL:COL
-   |
-   = note: in this trait
-  ::: $SRC_DIR/core/src/convert/mod.rs:LL:COL
-   |
-   = note: this trait's method doesn't have the requirement `_ <: _`
+error: aborting due to 1 previous error
 
-error[E0282]: type annotations needed
-  --> $DIR/conflicting-impls.rs:14:5
-   |
-LL |     fn try_from(_: Ty) -> Result<Self, Self::Error> {
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot infer type
-   |
-note: the requirement `_ <: _` appears on the `impl`'s method `try_from` but not on the corresponding trait's method
-  --> $SRC_DIR/core/src/convert/mod.rs:LL:COL
-   |
-   = note: in this trait
-  ::: $SRC_DIR/core/src/convert/mod.rs:LL:COL
-   |
-   = note: this trait's method doesn't have the requirement `_ <: _`
-
-error: aborting due to 3 previous errors
-
-Some errors have detailed explanations: E0119, E0282.
-For more information about an error, try `rustc --explain E0119`.
+For more information about this error, try `rustc --explain E0119`.

From 9ed6e608c92632389b5397744b32e75a24afb884 Mon Sep 17 00:00:00 2001
From: DianQK <dianqk@dianqk.net>
Date: Tue, 9 Apr 2024 21:44:50 +0800
Subject: [PATCH 04/17] Use `isCI` in `run.sh`

---
 src/ci/docker/run.sh | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/ci/docker/run.sh b/src/ci/docker/run.sh
index 9d72fd8a55a7..30c28a809be3 100755
--- a/src/ci/docker/run.sh
+++ b/src/ci/docker/run.sh
@@ -46,7 +46,7 @@ source "$ci_dir/shared.sh"
 CACHE_DOMAIN="${CACHE_DOMAIN:-ci-caches.rust-lang.org}"
 
 if [ -f "$docker_dir/$image/Dockerfile" ]; then
-    if [ "$CI" != "" ]; then
+    if isCI; then
       hash_key=/tmp/.docker-hash-key.txt
       rm -f "${hash_key}"
       echo $image >> $hash_key
@@ -102,7 +102,7 @@ if [ -f "$docker_dir/$image/Dockerfile" ]; then
     CACHE_IMAGE_TAG=${REGISTRY}/${REGISTRY_USERNAME}/rust-ci-cache:${cksum}
 
     # On non-CI jobs, we don't do any caching.
-    if [[ "$CI" == "" ]];
+    if ! isCI;
     then
         retry docker build --rm -t rust-ci -f "$dockerfile" "$context"
     # On PR CI jobs, we don't have permissions to write to the registry cache,
@@ -289,7 +289,7 @@ else
   command=(/checkout/src/ci/run.sh)
 fi
 
-if [ "$CI" != "" ]; then
+if isCI; then
   # Get some needed information for $BASE_COMMIT
   #
   # This command gets the last merge commit which we'll use as base to list

From d92f01a78d1baaf8fc1d8ef49049259b4e2676fc Mon Sep 17 00:00:00 2001
From: DianQK <dianqk@dianqk.net>
Date: Tue, 9 Apr 2024 21:46:04 +0800
Subject: [PATCH 05/17] Only output to `GITHUB_STEP_SUMMARY` in a CI
 environment

---
 src/ci/docker/run.sh | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/ci/docker/run.sh b/src/ci/docker/run.sh
index 30c28a809be3..df90c3875b14 100755
--- a/src/ci/docker/run.sh
+++ b/src/ci/docker/run.sh
@@ -339,7 +339,9 @@ docker \
   rust-ci \
   "${command[@]}"
 
-cat $objdir/${SUMMARY_FILE} >> "${GITHUB_STEP_SUMMARY}"
+if isCI; then
+    cat $objdir/${SUMMARY_FILE} >> "${GITHUB_STEP_SUMMARY}"
+fi
 
 if [ -f /.dockerenv ]; then
   rm -rf $objdir

From 86e939e9d545a7cac41c74e6650c9c43e7f101c3 Mon Sep 17 00:00:00 2001
From: DianQK <dianqk@dianqk.net>
Date: Tue, 9 Apr 2024 21:59:36 +0800
Subject: [PATCH 06/17] Change the output artifact path to
 `$root_dir/obj/$image` when running locally

---
 src/ci/docker/README.md | 11 ++++-------
 src/ci/docker/run.sh    | 10 +++++++---
 2 files changed, 11 insertions(+), 10 deletions(-)

diff --git a/src/ci/docker/README.md b/src/ci/docker/README.md
index 2e6456837130..9af368ef4450 100644
--- a/src/ci/docker/README.md
+++ b/src/ci/docker/README.md
@@ -14,7 +14,7 @@ for example:
 ./src/ci/docker/run.sh x86_64-gnu
 ```
 
-Images will output artifacts in an `obj` dir at the root of a repository. Note
+Images will output artifacts in an `obj/$image_name` dir at the root of a repository. Note
 that the script will overwrite the contents of this directory.
 
 To match conditions in rusts CI, also set the environment variable `DEPLOY=1`, e.g.:
@@ -22,12 +22,9 @@ To match conditions in rusts CI, also set the environment variable `DEPLOY=1`, e
 DEPLOY=1 ./src/ci/docker/run.sh x86_64-gnu
 ```
 
-**NOTE**: Re-using the same `obj` dir with different docker images with
-the same target triple (e.g. `dist-x86_64-linux` and `dist-various-1`)
-may result in strange linker errors, due shared library versions differing between platforms.
-
-If you encounter any issues when using multiple Docker images, try deleting your `obj` directory
-before running your command.
+**NOTE**: In CI, the script outputs the artifacts to the `obj` directory,
+while locally, to the `obj/$image_name` directory. This is primarily to prevent
+strange linker errors when using multiple Docker images.
 
 ## Filesystem layout
 
diff --git a/src/ci/docker/run.sh b/src/ci/docker/run.sh
index df90c3875b14..fcc507b572c2 100755
--- a/src/ci/docker/run.sh
+++ b/src/ci/docker/run.sh
@@ -33,7 +33,13 @@ ci_dir="`dirname $script_dir`"
 src_dir="`dirname $ci_dir`"
 root_dir="`dirname $src_dir`"
 
-objdir=$root_dir/obj
+source "$ci_dir/shared.sh"
+
+if isCI; then
+    objdir=$root_dir/obj
+else
+    objdir=$root_dir/obj/$image
+fi
 dist=$objdir/build/dist
 
 
@@ -41,8 +47,6 @@ if [ -d "$root_dir/.git" ]; then
     IS_GIT_SOURCE=1
 fi
 
-source "$ci_dir/shared.sh"
-
 CACHE_DOMAIN="${CACHE_DOMAIN:-ci-caches.rust-lang.org}"
 
 if [ -f "$docker_dir/$image/Dockerfile" ]; then

From 8f3d7fe0388c433008a91da14ef92de9a338b237 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Le=C3=B3n=20Orell=20Valerian=20Liehr?= <me@fmease.dev>
Date: Thu, 19 Oct 2023 23:15:21 +0200
Subject: [PATCH 07/17] meta: notify #t-rustdoc Zulip stream on backport
 nominations

---
 triagebot.toml | 48 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 48 insertions(+)

diff --git a/triagebot.toml b/triagebot.toml
index b96225c45205..f92f800ea9eb 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -417,6 +417,54 @@ message_on_remove = "Issue #{number}'s prioritization request has been removed."
 message_on_close = "Issue #{number} has been closed while requested for prioritization."
 message_on_reopen = "Issue #{number} has been reopened."
 
+# FIXME: Patch triagebot to support `notify-zulip.<label>` getting mapped to an array of actions.
+#        At the moment, the beta-nominated+T-rustdoc action fully occupies the beta-nominated slot
+#        preventing others from adding more beta-nominated actions.
+[notify-zulip."beta-nominated"]
+required_labels = ["T-rustdoc"]
+zulip_stream = 266220 # #t-rustdoc
+topic = "beta-nominated: #{number}"
+# Zulip polls may not be preceded by any other text and pings & short links inside
+# the title of a poll don't get recognized. Therefore we need to send two messages.
+message_on_add = [
+    """\
+@*T-rustdoc* PR #{number} "{title}" has been nominated for beta backport.
+""",
+    """\
+/poll Approve beta backport of #{number}?
+approve
+decline
+don't know
+""",
+]
+message_on_remove = "PR #{number}'s beta-nomination has been removed."
+message_on_close = "PR #{number} has been closed. Thanks for participating!"
+message_on_reopen = "PR #{number} has been reopened. Pinging @*T-rustdoc*."
+
+# FIXME: Patch triagebot to support `notify-zulip.<label>` getting mapped to an array of actions.
+#        At the moment, the stable-nominated+T-rustdoc action fully occupies the stable-nominated slot
+#        preventing others from adding more stable-nominated actions.
+[notify-zulip."stable-nominated"]
+required_labels = ["T-rustdoc"]
+zulip_stream = 266220 # #t-rustdoc
+topic = "stable-nominated: #{number}"
+# Zulip polls may not be preceded by any other text and pings & short links inside
+# the title of a poll don't get recognized. Therefore we need to send two messages.
+message_on_add = [
+    """\
+@*T-rustdoc* PR #{number} "{title}" has been nominated for stable backport.
+""",
+    """\
+/poll Approve stable backport of #{number}?
+approve
+decline
+don't know
+""",
+]
+message_on_remove = "PR #{number}'s stable-nomination has been removed."
+message_on_close = "PR #{number} has been closed. Thanks for participating!"
+message_on_reopen = "PR #{number} has been reopened. Pinging @*T-rustdoc*."
+
 [notify-zulip."I-types-nominated"]
 zulip_stream = 326866 # #T-types/nominated
 topic = "#{number}: {title}"

From 8bbaeee6f982dfbfa72ad226ed3c19e29e65257b Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Tue, 16 Apr 2024 15:56:48 -0400
Subject: [PATCH 08/17] Don't proceed into parent bodies when collecting stmts
 for possible return suggestion

---
 .../rustc_hir_typeck/src/fn_ctxt/checks.rs    |  8 +++++--
 .../dont-collect-stmts-from-parent-body.rs    | 15 ++++++++++++
 ...dont-collect-stmts-from-parent-body.stderr | 24 +++++++++++++++++++
 3 files changed, 45 insertions(+), 2 deletions(-)
 create mode 100644 tests/ui/inference/dont-collect-stmts-from-parent-body.rs
 create mode 100644 tests/ui/inference/dont-collect-stmts-from-parent-body.stderr

diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
index f346c6446e00..be1cf08cca26 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
@@ -2016,12 +2016,16 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         for (span, code) in errors_causecode {
             self.dcx().try_steal_modify_and_emit_err(span, StashKey::MaybeForgetReturn, |err| {
                 if let Some(fn_sig) = self.body_fn_sig()
-                    && let ExprBindingObligation(_, _, hir_id, ..) = code
+                    && let ExprBindingObligation(_, _, binding_hir_id, ..) = code
                     && !fn_sig.output().is_unit()
                 {
                     let mut block_num = 0;
                     let mut found_semi = false;
-                    for (_, node) in self.tcx.hir().parent_iter(hir_id) {
+                    for (hir_id, node) in self.tcx.hir().parent_iter(binding_hir_id) {
+                        // Don't proceed into parent bodies
+                        if hir_id.owner != binding_hir_id.owner {
+                            break;
+                        }
                         match node {
                             hir::Node::Stmt(stmt) => {
                                 if let hir::StmtKind::Semi(expr) = stmt.kind {
diff --git a/tests/ui/inference/dont-collect-stmts-from-parent-body.rs b/tests/ui/inference/dont-collect-stmts-from-parent-body.rs
new file mode 100644
index 000000000000..635fe74b8679
--- /dev/null
+++ b/tests/ui/inference/dont-collect-stmts-from-parent-body.rs
@@ -0,0 +1,15 @@
+// issue: rust-lang/rust#124022
+
+struct Type<T>;
+//~^ ERROR type parameter `T` is never used
+
+fn main() {
+    {
+        impl<T> Type<T> {
+            fn new() -> Type<T> {
+                Type
+                //~^ ERROR type annotations needed
+            }
+        }
+    };
+}
diff --git a/tests/ui/inference/dont-collect-stmts-from-parent-body.stderr b/tests/ui/inference/dont-collect-stmts-from-parent-body.stderr
new file mode 100644
index 000000000000..f82527273fbe
--- /dev/null
+++ b/tests/ui/inference/dont-collect-stmts-from-parent-body.stderr
@@ -0,0 +1,24 @@
+error[E0392]: type parameter `T` is never used
+  --> $DIR/dont-collect-stmts-from-parent-body.rs:3:13
+   |
+LL | struct Type<T>;
+   |             ^ unused type parameter
+   |
+   = help: consider removing `T`, referring to it in a field, or using a marker such as `PhantomData`
+   = help: if you intended `T` to be a const parameter, use `const T: /* Type */` instead
+
+error[E0282]: type annotations needed
+  --> $DIR/dont-collect-stmts-from-parent-body.rs:10:17
+   |
+LL |                 Type
+   |                 ^^^^ cannot infer type of the type parameter `T` declared on the struct `Type`
+   |
+help: consider specifying the generic argument
+   |
+LL |                 Type::<T>
+   |                     +++++
+
+error: aborting due to 2 previous errors
+
+Some errors have detailed explanations: E0282, E0392.
+For more information about an error, try `rustc --explain E0282`.

From 20414b8e1f9c92c30fb7ff79f0a75c6a7ac78214 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Maik=20Allg=C3=B6wer?= <user1391@gmail.com>
Date: Tue, 16 Apr 2024 23:30:05 +0200
Subject: [PATCH 09/17] Add another expression to weird-exprs.rs

---
 tests/ui/weird-exprs.rs | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/tests/ui/weird-exprs.rs b/tests/ui/weird-exprs.rs
index d856b06e260b..0009ed0e34c8 100644
--- a/tests/ui/weird-exprs.rs
+++ b/tests/ui/weird-exprs.rs
@@ -256,6 +256,20 @@ fn fake_macros() -> impl std::fmt::Debug {
     }
 }
 
+fn fish_fight() {
+    trait Rope {
+        fn _____________<U>(_: Self, _: U) where Self: Sized {}
+    }
+
+    struct T;
+
+    impl Rope for T {}
+
+    fn tug_o_war(_: impl Fn(T, T)) {}
+
+    tug_o_war(<T>::_____________::<T>);
+}
+
 pub fn main() {
     strange();
     funny();
@@ -284,4 +298,5 @@ pub fn main() {
     infcx();
     return_already();
     fake_macros();
+    fish_fight();
 }

From b7f433273723cc88799088917abed3a3b31a215a Mon Sep 17 00:00:00 2001
From: Slanterns <slanterns.w@gmail.com>
Date: Wed, 17 Apr 2024 08:09:13 +0800
Subject: [PATCH 10/17] Stabilize `const_io_structs`

---
 library/std/src/io/cursor.rs | 6 +++---
 library/std/src/io/util.rs   | 6 +++---
 library/std/src/lib.rs       | 1 -
 3 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/library/std/src/io/cursor.rs b/library/std/src/io/cursor.rs
index 49dde828c1fc..5b782fff7e52 100644
--- a/library/std/src/io/cursor.rs
+++ b/library/std/src/io/cursor.rs
@@ -95,7 +95,7 @@ impl<T> Cursor<T> {
     /// # force_inference(&buff);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[rustc_const_unstable(feature = "const_io_structs", issue = "78812")]
+    #[rustc_const_stable(feature = "const_io_structs", since = "CURRENT_RUSTC_VERSION")]
     pub const fn new(inner: T) -> Cursor<T> {
         Cursor { pos: 0, inner }
     }
@@ -132,7 +132,7 @@ impl<T> Cursor<T> {
     /// let reference = buff.get_ref();
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[rustc_const_unstable(feature = "const_io_structs", issue = "78812")]
+    #[rustc_const_stable(feature = "const_io_structs", since = "CURRENT_RUSTC_VERSION")]
     pub const fn get_ref(&self) -> &T {
         &self.inner
     }
@@ -178,7 +178,7 @@ impl<T> Cursor<T> {
     /// assert_eq!(buff.position(), 1);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[rustc_const_unstable(feature = "const_io_structs", issue = "78812")]
+    #[rustc_const_stable(feature = "const_io_structs", since = "CURRENT_RUSTC_VERSION")]
     pub const fn position(&self) -> u64 {
         self.pos
     }
diff --git a/library/std/src/io/util.rs b/library/std/src/io/util.rs
index 16eaed15e720..266a447f06b5 100644
--- a/library/std/src/io/util.rs
+++ b/library/std/src/io/util.rs
@@ -51,7 +51,7 @@ pub struct Empty;
 /// ```
 #[must_use]
 #[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_const_unstable(feature = "const_io_structs", issue = "78812")]
+#[rustc_const_stable(feature = "const_io_structs", since = "CURRENT_RUSTC_VERSION")]
 pub const fn empty() -> Empty {
     Empty
 }
@@ -173,7 +173,7 @@ pub struct Repeat {
 /// ```
 #[must_use]
 #[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_const_unstable(feature = "const_io_structs", issue = "78812")]
+#[rustc_const_stable(feature = "const_io_structs", since = "CURRENT_RUSTC_VERSION")]
 pub const fn repeat(byte: u8) -> Repeat {
     Repeat { byte }
 }
@@ -276,7 +276,7 @@ pub struct Sink;
 /// ```
 #[must_use]
 #[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_const_unstable(feature = "const_io_structs", issue = "78812")]
+#[rustc_const_stable(feature = "const_io_structs", since = "CURRENT_RUSTC_VERSION")]
 pub const fn sink() -> Sink {
     Sink
 }
diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs
index 72ae38cfa20e..d152626d86a0 100644
--- a/library/std/src/lib.rs
+++ b/library/std/src/lib.rs
@@ -407,7 +407,6 @@
 // tidy-alphabetical-start
 #![feature(const_collections_with_hasher)]
 #![feature(const_hash)]
-#![feature(const_io_structs)]
 #![feature(const_ip)]
 #![feature(const_ipv4)]
 #![feature(const_ipv6)]

From 87db7c32a70238785083b6de772cfd00e0adbc10 Mon Sep 17 00:00:00 2001
From: Noa <coolreader18@gmail.com>
Date: Wed, 17 Apr 2024 00:18:04 -0500
Subject: [PATCH 11/17] Address comments

---
 library/alloc/src/collections/vec_deque/mod.rs | 4 +---
 library/core/src/cell.rs                       | 2 +-
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/library/alloc/src/collections/vec_deque/mod.rs b/library/alloc/src/collections/vec_deque/mod.rs
index 8df7ca3411d6..fb0989523930 100644
--- a/library/alloc/src/collections/vec_deque/mod.rs
+++ b/library/alloc/src/collections/vec_deque/mod.rs
@@ -116,9 +116,7 @@ impl<T: Clone, A: Allocator + Clone> Clone for VecDeque<T, A> {
     /// Overwrites the contents of `self` with a clone of the contents of `source`.
     ///
     /// This method is preferred over simply assigning `source.clone()` to `self`,
-    /// as it avoids reallocation if possible. Additionally, if the element type
-    /// `T` overrides `clone_from()`, this will reuse the resources of `self`'s
-    /// elements as well.
+    /// as it avoids reallocation if possible.
     fn clone_from(&mut self, source: &Self) {
         self.clear();
         self.extend(source.iter().cloned());
diff --git a/library/core/src/cell.rs b/library/core/src/cell.rs
index 835edc4424d8..5f3daca50084 100644
--- a/library/core/src/cell.rs
+++ b/library/core/src/cell.rs
@@ -1273,7 +1273,7 @@ impl<T: Clone> Clone for RefCell<T> {
 
     /// # Panics
     ///
-    /// Panics if `other` is currently mutably borrowed.
+    /// Panics if `source` is currently mutably borrowed.
     #[inline]
     #[track_caller]
     fn clone_from(&mut self, source: &Self) {

From 9e239bdc764f8845b8959962cfaf654524a12b38 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Tue, 16 Apr 2024 18:03:05 +0200
Subject: [PATCH 12/17] interpret: pass MemoryKind to adjust_alloc_base_pointer

---
 .../rustc_const_eval/src/interpret/machine.rs | 25 ++++++++++++-------
 .../rustc_const_eval/src/interpret/memory.rs  | 10 ++++++--
 src/tools/miri/src/alloc_addresses/mod.rs     | 15 +++++++----
 src/tools/miri/src/machine.rs                 |  6 +++--
 4 files changed, 38 insertions(+), 18 deletions(-)

diff --git a/compiler/rustc_const_eval/src/interpret/machine.rs b/compiler/rustc_const_eval/src/interpret/machine.rs
index 3aeae5ebf6de..3e4be73e14fb 100644
--- a/compiler/rustc_const_eval/src/interpret/machine.rs
+++ b/compiler/rustc_const_eval/src/interpret/machine.rs
@@ -301,15 +301,6 @@ pub trait Machine<'mir, 'tcx: 'mir>: Sized {
         def_id: DefId,
     ) -> InterpResult<'tcx, Pointer<Self::Provenance>>;
 
-    /// Return a "base" pointer for the given allocation: the one that is used for direct
-    /// accesses to this static/const/fn allocation, or the one returned from the heap allocator.
-    ///
-    /// Not called on `extern` or thread-local statics (those use the methods above).
-    fn adjust_alloc_base_pointer(
-        ecx: &InterpCx<'mir, 'tcx, Self>,
-        ptr: Pointer,
-    ) -> InterpResult<'tcx, Pointer<Self::Provenance>>;
-
     /// "Int-to-pointer cast"
     fn ptr_from_addr_cast(
         ecx: &InterpCx<'mir, 'tcx, Self>,
@@ -336,6 +327,8 @@ pub trait Machine<'mir, 'tcx: 'mir>: Sized {
 
     /// Called to adjust allocations to the Provenance and AllocExtra of this machine.
     ///
+    /// If `alloc` contains pointers, then they are all pointing to globals.
+    ///
     /// The way we construct allocations is to always first construct it without extra and then add
     /// the extra. This keeps uniform code paths for handling both allocations created by CTFE for
     /// globals, and allocations created by Miri during evaluation.
@@ -354,6 +347,19 @@ pub trait Machine<'mir, 'tcx: 'mir>: Sized {
         kind: Option<MemoryKind<Self::MemoryKind>>,
     ) -> InterpResult<'tcx, Cow<'b, Allocation<Self::Provenance, Self::AllocExtra, Self::Bytes>>>;
 
+    /// Return a "root" pointer for the given allocation: the one that is used for direct
+    /// accesses to this static/const/fn allocation, or the one returned from the heap allocator.
+    ///
+    /// Not called on `extern` or thread-local statics (those use the methods above).
+    ///
+    /// `kind` is the kind of the allocation the pointer points to; it can be `None` when
+    /// it's a global and `GLOBAL_KIND` is `None`.
+    fn adjust_alloc_base_pointer(
+        ecx: &InterpCx<'mir, 'tcx, Self>,
+        ptr: Pointer,
+        kind: Option<MemoryKind<Self::MemoryKind>>,
+    ) -> InterpResult<'tcx, Pointer<Self::Provenance>>;
+
     /// Evaluate the inline assembly.
     ///
     /// This should take care of jumping to the next block (one of `targets`) when asm goto
@@ -604,6 +610,7 @@ pub macro compile_time_machine(<$mir: lifetime, $tcx: lifetime>) {
     fn adjust_alloc_base_pointer(
         _ecx: &InterpCx<$mir, $tcx, Self>,
         ptr: Pointer<CtfeProvenance>,
+        _kind: Option<MemoryKind<Self::MemoryKind>>,
     ) -> InterpResult<$tcx, Pointer<CtfeProvenance>> {
         Ok(ptr)
     }
diff --git a/compiler/rustc_const_eval/src/interpret/memory.rs b/compiler/rustc_const_eval/src/interpret/memory.rs
index fbb0907f7d05..2820b0629809 100644
--- a/compiler/rustc_const_eval/src/interpret/memory.rs
+++ b/compiler/rustc_const_eval/src/interpret/memory.rs
@@ -180,10 +180,16 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
             Some(GlobalAlloc::Static(def_id)) if self.tcx.is_foreign_item(def_id) => {
                 return M::extern_static_base_pointer(self, def_id);
             }
+            None => {
+                assert!(
+                    self.memory.extra_fn_ptr_map.contains_key(&alloc_id),
+                    "{alloc_id:?} is neither global nor a function pointer"
+                );
+            }
             _ => {}
         }
         // And we need to get the provenance.
-        M::adjust_alloc_base_pointer(self, ptr)
+        M::adjust_alloc_base_pointer(self, ptr, M::GLOBAL_KIND.map(MemoryKind::Machine))
     }
 
     pub fn fn_ptr(&mut self, fn_val: FnVal<'tcx, M::ExtraFnVal>) -> Pointer<M::Provenance> {
@@ -240,7 +246,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         );
         let alloc = M::adjust_allocation(self, id, Cow::Owned(alloc), Some(kind))?;
         self.memory.alloc_map.insert(id, (kind, alloc.into_owned()));
-        M::adjust_alloc_base_pointer(self, Pointer::from(id))
+        M::adjust_alloc_base_pointer(self, Pointer::from(id), Some(kind))
     }
 
     pub fn reallocate_ptr(
diff --git a/src/tools/miri/src/alloc_addresses/mod.rs b/src/tools/miri/src/alloc_addresses/mod.rs
index fec39ec2b8e3..22f9a90a80af 100644
--- a/src/tools/miri/src/alloc_addresses/mod.rs
+++ b/src/tools/miri/src/alloc_addresses/mod.rs
@@ -141,7 +141,11 @@ trait EvalContextExtPriv<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
         }
     }
 
-    fn addr_from_alloc_id(&self, alloc_id: AllocId) -> InterpResult<'tcx, u64> {
+    fn addr_from_alloc_id(
+        &self,
+        alloc_id: AllocId,
+        _kind: MemoryKind,
+    ) -> InterpResult<'tcx, u64> {
         let ecx = self.eval_context_ref();
         let mut global_state = ecx.machine.alloc_addresses.borrow_mut();
         let global_state = &mut *global_state;
@@ -283,16 +287,17 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
     }
 
     /// Convert a relative (tcx) pointer to a Miri pointer.
-    fn ptr_from_rel_ptr(
+    fn adjust_alloc_base_pointer(
         &self,
         ptr: Pointer<CtfeProvenance>,
         tag: BorTag,
+        kind: MemoryKind,
     ) -> InterpResult<'tcx, Pointer<Provenance>> {
         let ecx = self.eval_context_ref();
 
         let (prov, offset) = ptr.into_parts(); // offset is relative (AllocId provenance)
         let alloc_id = prov.alloc_id();
-        let base_addr = ecx.addr_from_alloc_id(alloc_id)?;
+        let base_addr = ecx.addr_from_alloc_id(alloc_id, kind)?;
 
         // Add offset with the right kind of pointer-overflowing arithmetic.
         let dl = ecx.data_layout();
@@ -314,9 +319,9 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
             ecx.alloc_id_from_addr(addr.bytes())?
         };
 
-        // This cannot fail: since we already have a pointer with that provenance, rel_ptr_to_addr
+        // This cannot fail: since we already have a pointer with that provenance, adjust_alloc_base_pointer
         // must have been called in the past, so we can just look up the address in the map.
-        let base_addr = ecx.addr_from_alloc_id(alloc_id).unwrap();
+        let base_addr = *ecx.machine.alloc_addresses.borrow().base_addr.get(&alloc_id).unwrap();
 
         // Wrapping "addr - base_addr"
         #[allow(clippy::cast_possible_wrap)] // we want to wrap here
diff --git a/src/tools/miri/src/machine.rs b/src/tools/miri/src/machine.rs
index 1d06d5c69d36..2bd1b24ee916 100644
--- a/src/tools/miri/src/machine.rs
+++ b/src/tools/miri/src/machine.rs
@@ -1090,7 +1090,7 @@ impl<'mir, 'tcx> Machine<'mir, 'tcx> for MiriMachine<'mir, 'tcx> {
         alloc: Cow<'b, Allocation>,
         kind: Option<MemoryKind>,
     ) -> InterpResult<'tcx, Cow<'b, Allocation<Self::Provenance, Self::AllocExtra>>> {
-        let kind = kind.expect("we set our STATIC_KIND so this cannot be None");
+        let kind = kind.expect("we set our GLOBAL_KIND so this cannot be None");
         if ecx.machine.tracked_alloc_ids.contains(&id) {
             ecx.emit_diagnostic(NonHaltingDiagnostic::CreatedAlloc(
                 id,
@@ -1151,7 +1151,9 @@ impl<'mir, 'tcx> Machine<'mir, 'tcx> for MiriMachine<'mir, 'tcx> {
     fn adjust_alloc_base_pointer(
         ecx: &MiriInterpCx<'mir, 'tcx>,
         ptr: Pointer<CtfeProvenance>,
+        kind: Option<MemoryKind>,
     ) -> InterpResult<'tcx, Pointer<Provenance>> {
+        let kind = kind.expect("we set our GLOBAL_KIND so this cannot be None");
         let alloc_id = ptr.provenance.alloc_id();
         if cfg!(debug_assertions) {
             // The machine promises to never call us on thread-local or extern statics.
@@ -1172,7 +1174,7 @@ impl<'mir, 'tcx> Machine<'mir, 'tcx> for MiriMachine<'mir, 'tcx> {
             // Value does not matter, SB is disabled
             BorTag::default()
         };
-        ecx.ptr_from_rel_ptr(ptr, tag)
+        ecx.adjust_alloc_base_pointer(ptr, tag, kind)
     }
 
     /// Called on `usize as ptr` casts.

From ae7b07f2dc9b07aceab318829538222666945efc Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Tue, 16 Apr 2024 18:37:56 +0200
Subject: [PATCH 13/17] interpret: rename base_pointer -> root_pointer

also in Miri, "base tag" -> "root tag"
---
 .../rustc_const_eval/src/interpret/machine.rs  | 12 ++++++------
 .../rustc_const_eval/src/interpret/memory.rs   | 12 ++++++------
 .../rustc_const_eval/src/interpret/operand.rs  |  6 +++---
 .../rustc_const_eval/src/interpret/place.rs    |  2 +-
 .../rustc_const_eval/src/interpret/step.rs     |  2 +-
 .../rustc_const_eval/src/interpret/traits.rs   |  2 +-
 src/tools/miri/src/alloc_addresses/mod.rs      |  4 ++--
 src/tools/miri/src/borrow_tracker/mod.rs       | 18 +++++++++---------
 .../stacked_borrows/diagnostics.rs             | 12 ++++++------
 .../src/borrow_tracker/stacked_borrows/mod.rs  |  4 ++--
 .../borrow_tracker/stacked_borrows/stack.rs    | 10 +++++-----
 .../src/borrow_tracker/tree_borrows/mod.rs     |  2 +-
 src/tools/miri/src/machine.rs                  | 18 +++++++++---------
 .../invalidate_against_protector3.stack.stderr |  2 +-
 14 files changed, 53 insertions(+), 53 deletions(-)

diff --git a/compiler/rustc_const_eval/src/interpret/machine.rs b/compiler/rustc_const_eval/src/interpret/machine.rs
index 3e4be73e14fb..7617cb57b3cd 100644
--- a/compiler/rustc_const_eval/src/interpret/machine.rs
+++ b/compiler/rustc_const_eval/src/interpret/machine.rs
@@ -288,15 +288,15 @@ pub trait Machine<'mir, 'tcx: 'mir>: Sized {
     }
 
     /// Return the `AllocId` for the given thread-local static in the current thread.
-    fn thread_local_static_base_pointer(
+    fn thread_local_static_pointer(
         _ecx: &mut InterpCx<'mir, 'tcx, Self>,
         def_id: DefId,
     ) -> InterpResult<'tcx, Pointer<Self::Provenance>> {
         throw_unsup!(ThreadLocalStatic(def_id))
     }
 
-    /// Return the root pointer for the given `extern static`.
-    fn extern_static_base_pointer(
+    /// Return the `AllocId` for the given `extern static`.
+    fn extern_static_pointer(
         ecx: &InterpCx<'mir, 'tcx, Self>,
         def_id: DefId,
     ) -> InterpResult<'tcx, Pointer<Self::Provenance>>;
@@ -354,7 +354,7 @@ pub trait Machine<'mir, 'tcx: 'mir>: Sized {
     ///
     /// `kind` is the kind of the allocation the pointer points to; it can be `None` when
     /// it's a global and `GLOBAL_KIND` is `None`.
-    fn adjust_alloc_base_pointer(
+    fn adjust_alloc_root_pointer(
         ecx: &InterpCx<'mir, 'tcx, Self>,
         ptr: Pointer,
         kind: Option<MemoryKind<Self::MemoryKind>>,
@@ -598,7 +598,7 @@ pub macro compile_time_machine(<$mir: lifetime, $tcx: lifetime>) {
         Ok(alloc)
     }
 
-    fn extern_static_base_pointer(
+    fn extern_static_pointer(
         ecx: &InterpCx<$mir, $tcx, Self>,
         def_id: DefId,
     ) -> InterpResult<$tcx, Pointer> {
@@ -607,7 +607,7 @@ pub macro compile_time_machine(<$mir: lifetime, $tcx: lifetime>) {
     }
 
     #[inline(always)]
-    fn adjust_alloc_base_pointer(
+    fn adjust_alloc_root_pointer(
         _ecx: &InterpCx<$mir, $tcx, Self>,
         ptr: Pointer<CtfeProvenance>,
         _kind: Option<MemoryKind<Self::MemoryKind>>,
diff --git a/compiler/rustc_const_eval/src/interpret/memory.rs b/compiler/rustc_const_eval/src/interpret/memory.rs
index 2820b0629809..594e3b3212f2 100644
--- a/compiler/rustc_const_eval/src/interpret/memory.rs
+++ b/compiler/rustc_const_eval/src/interpret/memory.rs
@@ -165,7 +165,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
     ///
     /// This function can fail only if `ptr` points to an `extern static`.
     #[inline]
-    pub fn global_base_pointer(
+    pub fn global_root_pointer(
         &self,
         ptr: Pointer<CtfeProvenance>,
     ) -> InterpResult<'tcx, Pointer<M::Provenance>> {
@@ -178,7 +178,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                 bug!("global memory cannot point to thread-local static")
             }
             Some(GlobalAlloc::Static(def_id)) if self.tcx.is_foreign_item(def_id) => {
-                return M::extern_static_base_pointer(self, def_id);
+                return M::extern_static_pointer(self, def_id);
             }
             None => {
                 assert!(
@@ -189,7 +189,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
             _ => {}
         }
         // And we need to get the provenance.
-        M::adjust_alloc_base_pointer(self, ptr, M::GLOBAL_KIND.map(MemoryKind::Machine))
+        M::adjust_alloc_root_pointer(self, ptr, M::GLOBAL_KIND.map(MemoryKind::Machine))
     }
 
     pub fn fn_ptr(&mut self, fn_val: FnVal<'tcx, M::ExtraFnVal>) -> Pointer<M::Provenance> {
@@ -203,9 +203,9 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                 id
             }
         };
-        // Functions are global allocations, so make sure we get the right base pointer.
+        // Functions are global allocations, so make sure we get the right root pointer.
         // We know this is not an `extern static` so this cannot fail.
-        self.global_base_pointer(Pointer::from(id)).unwrap()
+        self.global_root_pointer(Pointer::from(id)).unwrap()
     }
 
     pub fn allocate_ptr(
@@ -246,7 +246,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         );
         let alloc = M::adjust_allocation(self, id, Cow::Owned(alloc), Some(kind))?;
         self.memory.alloc_map.insert(id, (kind, alloc.into_owned()));
-        M::adjust_alloc_base_pointer(self, Pointer::from(id), Some(kind))
+        M::adjust_alloc_root_pointer(self, Pointer::from(id), Some(kind))
     }
 
     pub fn reallocate_ptr(
diff --git a/compiler/rustc_const_eval/src/interpret/operand.rs b/compiler/rustc_const_eval/src/interpret/operand.rs
index 842fb6d204c2..c120154ce2a7 100644
--- a/compiler/rustc_const_eval/src/interpret/operand.rs
+++ b/compiler/rustc_const_eval/src/interpret/operand.rs
@@ -764,7 +764,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         // Other cases need layout.
         let adjust_scalar = |scalar| -> InterpResult<'tcx, _> {
             Ok(match scalar {
-                Scalar::Ptr(ptr, size) => Scalar::Ptr(self.global_base_pointer(ptr)?, size),
+                Scalar::Ptr(ptr, size) => Scalar::Ptr(self.global_root_pointer(ptr)?, size),
                 Scalar::Int(int) => Scalar::Int(int),
             })
         };
@@ -772,7 +772,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         let imm = match val_val {
             mir::ConstValue::Indirect { alloc_id, offset } => {
                 // This is const data, no mutation allowed.
-                let ptr = self.global_base_pointer(Pointer::new(
+                let ptr = self.global_root_pointer(Pointer::new(
                     CtfeProvenance::from(alloc_id).as_immutable(),
                     offset,
                 ))?;
@@ -784,7 +784,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                 // This is const data, no mutation allowed.
                 let alloc_id = self.tcx.reserve_and_set_memory_alloc(data);
                 let ptr = Pointer::new(CtfeProvenance::from(alloc_id).as_immutable(), Size::ZERO);
-                Immediate::new_slice(self.global_base_pointer(ptr)?.into(), meta, self)
+                Immediate::new_slice(self.global_root_pointer(ptr)?.into(), meta, self)
             }
         };
         Ok(OpTy { op: Operand::Immediate(imm), layout })
diff --git a/compiler/rustc_const_eval/src/interpret/place.rs b/compiler/rustc_const_eval/src/interpret/place.rs
index e32aea39fc59..1549eddabbcc 100644
--- a/compiler/rustc_const_eval/src/interpret/place.rs
+++ b/compiler/rustc_const_eval/src/interpret/place.rs
@@ -1010,7 +1010,7 @@ where
     ) -> InterpResult<'tcx, MPlaceTy<'tcx, M::Provenance>> {
         // This must be an allocation in `tcx`
         let _ = self.tcx.global_alloc(raw.alloc_id);
-        let ptr = self.global_base_pointer(Pointer::from(raw.alloc_id))?;
+        let ptr = self.global_root_pointer(Pointer::from(raw.alloc_id))?;
         let layout = self.layout_of(raw.ty)?;
         Ok(self.ptr_to_mplace(ptr.into(), layout))
     }
diff --git a/compiler/rustc_const_eval/src/interpret/step.rs b/compiler/rustc_const_eval/src/interpret/step.rs
index db6c2833b9d5..c3f26da8a79b 100644
--- a/compiler/rustc_const_eval/src/interpret/step.rs
+++ b/compiler/rustc_const_eval/src/interpret/step.rs
@@ -144,7 +144,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         use rustc_middle::mir::Rvalue::*;
         match *rvalue {
             ThreadLocalRef(did) => {
-                let ptr = M::thread_local_static_base_pointer(self, did)?;
+                let ptr = M::thread_local_static_pointer(self, did)?;
                 self.write_pointer(ptr, &dest)?;
             }
 
diff --git a/compiler/rustc_const_eval/src/interpret/traits.rs b/compiler/rustc_const_eval/src/interpret/traits.rs
index a9ca268a2a96..b603ef0d27a4 100644
--- a/compiler/rustc_const_eval/src/interpret/traits.rs
+++ b/compiler/rustc_const_eval/src/interpret/traits.rs
@@ -28,7 +28,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         ensure_monomorphic_enough(*self.tcx, poly_trait_ref)?;
 
         let vtable_symbolic_allocation = self.tcx.reserve_and_set_vtable_alloc(ty, poly_trait_ref);
-        let vtable_ptr = self.global_base_pointer(Pointer::from(vtable_symbolic_allocation))?;
+        let vtable_ptr = self.global_root_pointer(Pointer::from(vtable_symbolic_allocation))?;
         Ok(vtable_ptr.into())
     }
 
diff --git a/src/tools/miri/src/alloc_addresses/mod.rs b/src/tools/miri/src/alloc_addresses/mod.rs
index 22f9a90a80af..b4983656adc1 100644
--- a/src/tools/miri/src/alloc_addresses/mod.rs
+++ b/src/tools/miri/src/alloc_addresses/mod.rs
@@ -287,7 +287,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
     }
 
     /// Convert a relative (tcx) pointer to a Miri pointer.
-    fn adjust_alloc_base_pointer(
+    fn adjust_alloc_root_pointer(
         &self,
         ptr: Pointer<CtfeProvenance>,
         tag: BorTag,
@@ -319,7 +319,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
             ecx.alloc_id_from_addr(addr.bytes())?
         };
 
-        // This cannot fail: since we already have a pointer with that provenance, adjust_alloc_base_pointer
+        // This cannot fail: since we already have a pointer with that provenance, adjust_alloc_root_pointer
         // must have been called in the past, so we can just look up the address in the map.
         let base_addr = *ecx.machine.alloc_addresses.borrow().base_addr.get(&alloc_id).unwrap();
 
diff --git a/src/tools/miri/src/borrow_tracker/mod.rs b/src/tools/miri/src/borrow_tracker/mod.rs
index f21315790a57..24e2a9a74bbe 100644
--- a/src/tools/miri/src/borrow_tracker/mod.rs
+++ b/src/tools/miri/src/borrow_tracker/mod.rs
@@ -89,10 +89,10 @@ pub struct GlobalStateInner {
     borrow_tracker_method: BorrowTrackerMethod,
     /// Next unused pointer ID (tag).
     next_ptr_tag: BorTag,
-    /// Table storing the "base" tag for each allocation.
-    /// The base tag is the one used for the initial pointer.
+    /// Table storing the "root" tag for each allocation.
+    /// The root tag is the one used for the initial pointer.
     /// We need this in a separate table to handle cyclic statics.
-    base_ptr_tags: FxHashMap<AllocId, BorTag>,
+    root_ptr_tags: FxHashMap<AllocId, BorTag>,
     /// Next unused call ID (for protectors).
     next_call_id: CallId,
     /// All currently protected tags.
@@ -175,7 +175,7 @@ impl GlobalStateInner {
         GlobalStateInner {
             borrow_tracker_method,
             next_ptr_tag: BorTag::one(),
-            base_ptr_tags: FxHashMap::default(),
+            root_ptr_tags: FxHashMap::default(),
             next_call_id: NonZero::new(1).unwrap(),
             protected_tags: FxHashMap::default(),
             tracked_pointer_tags,
@@ -213,8 +213,8 @@ impl GlobalStateInner {
         }
     }
 
-    pub fn base_ptr_tag(&mut self, id: AllocId, machine: &MiriMachine<'_, '_>) -> BorTag {
-        self.base_ptr_tags.get(&id).copied().unwrap_or_else(|| {
+    pub fn root_ptr_tag(&mut self, id: AllocId, machine: &MiriMachine<'_, '_>) -> BorTag {
+        self.root_ptr_tags.get(&id).copied().unwrap_or_else(|| {
             let tag = self.new_ptr();
             if self.tracked_pointer_tags.contains(&tag) {
                 machine.emit_diagnostic(NonHaltingDiagnostic::CreatedPointerTag(
@@ -223,14 +223,14 @@ impl GlobalStateInner {
                     None,
                 ));
             }
-            trace!("New allocation {:?} has base tag {:?}", id, tag);
-            self.base_ptr_tags.try_insert(id, tag).unwrap();
+            trace!("New allocation {:?} has rpot tag {:?}", id, tag);
+            self.root_ptr_tags.try_insert(id, tag).unwrap();
             tag
         })
     }
 
     pub fn remove_unreachable_allocs(&mut self, allocs: &LiveAllocs<'_, '_, '_>) {
-        self.base_ptr_tags.retain(|id, _| allocs.is_live(*id));
+        self.root_ptr_tags.retain(|id, _| allocs.is_live(*id));
     }
 }
 
diff --git a/src/tools/miri/src/borrow_tracker/stacked_borrows/diagnostics.rs b/src/tools/miri/src/borrow_tracker/stacked_borrows/diagnostics.rs
index aa99a14b18e6..6d4a5bd41b1e 100644
--- a/src/tools/miri/src/borrow_tracker/stacked_borrows/diagnostics.rs
+++ b/src/tools/miri/src/borrow_tracker/stacked_borrows/diagnostics.rs
@@ -20,7 +20,7 @@ fn err_sb_ub<'tcx>(
 #[derive(Clone, Debug)]
 pub struct AllocHistory {
     id: AllocId,
-    base: (Item, Span),
+    root: (Item, Span),
     creations: smallvec::SmallVec<[Creation; 1]>,
     invalidations: smallvec::SmallVec<[Invalidation; 1]>,
     protectors: smallvec::SmallVec<[Protection; 1]>,
@@ -225,7 +225,7 @@ impl AllocHistory {
     pub fn new(id: AllocId, item: Item, machine: &MiriMachine<'_, '_>) -> Self {
         Self {
             id,
-            base: (item, machine.current_span()),
+            root: (item, machine.current_span()),
             creations: SmallVec::new(),
             invalidations: SmallVec::new(),
             protectors: SmallVec::new(),
@@ -342,15 +342,15 @@ impl<'history, 'ecx, 'mir, 'tcx> DiagnosticCx<'history, 'ecx, 'mir, 'tcx> {
                 })
             })
             .or_else(|| {
-                // If we didn't find a retag that created this tag, it might be the base tag of
+                // If we didn't find a retag that created this tag, it might be the root tag of
                 // this allocation.
-                if self.history.base.0.tag() == tag {
+                if self.history.root.0.tag() == tag {
                     Some((
                         format!(
-                            "{tag:?} was created here, as the base tag for {:?}",
+                            "{tag:?} was created here, as the root tag for {:?}",
                             self.history.id
                         ),
-                        self.history.base.1.data(),
+                        self.history.root.1.data(),
                     ))
                 } else {
                     None
diff --git a/src/tools/miri/src/borrow_tracker/stacked_borrows/mod.rs b/src/tools/miri/src/borrow_tracker/stacked_borrows/mod.rs
index b4005515d9d9..a6dd1d829cb4 100644
--- a/src/tools/miri/src/borrow_tracker/stacked_borrows/mod.rs
+++ b/src/tools/miri/src/borrow_tracker/stacked_borrows/mod.rs
@@ -518,9 +518,9 @@ impl Stacks {
             // not through a pointer). That is, whenever we directly write to a local, this will pop
             // everything else off the stack, invalidating all previous pointers,
             // and in particular, *all* raw pointers.
-            MemoryKind::Stack => (state.base_ptr_tag(id, machine), Permission::Unique),
+            MemoryKind::Stack => (state.root_ptr_tag(id, machine), Permission::Unique),
             // Everything else is shared by default.
-            _ => (state.base_ptr_tag(id, machine), Permission::SharedReadWrite),
+            _ => (state.root_ptr_tag(id, machine), Permission::SharedReadWrite),
         };
         Stacks::new(size, perm, base_tag, id, machine)
     }
diff --git a/src/tools/miri/src/borrow_tracker/stacked_borrows/stack.rs b/src/tools/miri/src/borrow_tracker/stacked_borrows/stack.rs
index 76430498e2bf..bebd14d2f1e7 100644
--- a/src/tools/miri/src/borrow_tracker/stacked_borrows/stack.rs
+++ b/src/tools/miri/src/borrow_tracker/stacked_borrows/stack.rs
@@ -47,7 +47,7 @@ impl Stack {
         let mut first_removed = None;
 
         // We never consider removing the bottom-most tag. For stacks without an unknown
-        // bottom this preserves the base tag.
+        // bottom this preserves the root tag.
         // Note that the algorithm below is based on considering the tag at read_idx - 1,
         // so precisely considering the tag at index 0 for removal when we have an unknown
         // bottom would complicate the implementation. The simplification of not considering
@@ -93,7 +93,7 @@ impl Stack {
                 self.unique_range = 0..self.len();
             }
 
-            // Replace any Items which have been collected with the base item, a known-good value.
+            // Replace any Items which have been collected with the root item, a known-good value.
             for i in 0..CACHE_LEN {
                 if self.cache.idx[i] >= first_removed {
                     self.cache.items[i] = self.borrows[0];
@@ -331,7 +331,7 @@ impl<'tcx> Stack {
         self.verify_cache_consistency();
     }
 
-    /// Construct a new `Stack` using the passed `Item` as the base tag.
+    /// Construct a new `Stack` using the passed `Item` as the root tag.
     pub fn new(item: Item) -> Self {
         Stack {
             borrows: vec![item],
@@ -438,8 +438,8 @@ impl<'tcx> Stack {
             let mut removed = 0;
             let mut cursor = 0;
             // Remove invalid entries from the cache by rotating them to the end of the cache, then
-            // keep track of how many invalid elements there are and overwrite them with the base tag.
-            // The base tag here serves as a harmless default value.
+            // keep track of how many invalid elements there are and overwrite them with the root tag.
+            // The root tag here serves as a harmless default value.
             for _ in 0..CACHE_LEN - 1 {
                 if self.cache.idx[cursor] >= start {
                     self.cache.idx[cursor..CACHE_LEN - removed].rotate_left(1);
diff --git a/src/tools/miri/src/borrow_tracker/tree_borrows/mod.rs b/src/tools/miri/src/borrow_tracker/tree_borrows/mod.rs
index 492e324de454..fc5eb942a27b 100644
--- a/src/tools/miri/src/borrow_tracker/tree_borrows/mod.rs
+++ b/src/tools/miri/src/borrow_tracker/tree_borrows/mod.rs
@@ -37,7 +37,7 @@ impl<'tcx> Tree {
         _kind: MemoryKind,
         machine: &MiriMachine<'_, 'tcx>,
     ) -> Self {
-        let tag = state.base_ptr_tag(id, machine); // Fresh tag for the root
+        let tag = state.root_ptr_tag(id, machine); // Fresh tag for the root
         let span = machine.current_span();
         Tree::new(tag, size, span)
     }
diff --git a/src/tools/miri/src/machine.rs b/src/tools/miri/src/machine.rs
index 2bd1b24ee916..0bfc59e67db1 100644
--- a/src/tools/miri/src/machine.rs
+++ b/src/tools/miri/src/machine.rs
@@ -503,7 +503,7 @@ pub struct MiriMachine<'mir, 'tcx> {
     /// Crates which are considered local for the purposes of error reporting.
     pub(crate) local_crates: Vec<CrateNum>,
 
-    /// Mapping extern static names to their base pointer.
+    /// Mapping extern static names to their pointer.
     extern_statics: FxHashMap<Symbol, Pointer<Provenance>>,
 
     /// The random number generator used for resolving non-determinism.
@@ -1042,14 +1042,14 @@ impl<'mir, 'tcx> Machine<'mir, 'tcx> for MiriMachine<'mir, 'tcx> {
         ecx.generate_nan(inputs)
     }
 
-    fn thread_local_static_base_pointer(
+    fn thread_local_static_pointer(
         ecx: &mut MiriInterpCx<'mir, 'tcx>,
         def_id: DefId,
     ) -> InterpResult<'tcx, Pointer<Provenance>> {
         ecx.get_or_create_thread_local_alloc(def_id)
     }
 
-    fn extern_static_base_pointer(
+    fn extern_static_pointer(
         ecx: &MiriInterpCx<'mir, 'tcx>,
         def_id: DefId,
     ) -> InterpResult<'tcx, Pointer<Provenance>> {
@@ -1135,7 +1135,7 @@ impl<'mir, 'tcx> Machine<'mir, 'tcx> for MiriMachine<'mir, 'tcx> {
                 weak_memory: buffer_alloc,
                 backtrace,
             },
-            |ptr| ecx.global_base_pointer(ptr),
+            |ptr| ecx.global_root_pointer(ptr),
         )?;
 
         if matches!(kind, MemoryKind::Machine(kind) if kind.should_save_allocation_span()) {
@@ -1148,7 +1148,7 @@ impl<'mir, 'tcx> Machine<'mir, 'tcx> for MiriMachine<'mir, 'tcx> {
         Ok(Cow::Owned(alloc))
     }
 
-    fn adjust_alloc_base_pointer(
+    fn adjust_alloc_root_pointer(
         ecx: &MiriInterpCx<'mir, 'tcx>,
         ptr: Pointer<CtfeProvenance>,
         kind: Option<MemoryKind>,
@@ -1159,22 +1159,22 @@ impl<'mir, 'tcx> Machine<'mir, 'tcx> for MiriMachine<'mir, 'tcx> {
             // The machine promises to never call us on thread-local or extern statics.
             match ecx.tcx.try_get_global_alloc(alloc_id) {
                 Some(GlobalAlloc::Static(def_id)) if ecx.tcx.is_thread_local_static(def_id) => {
-                    panic!("adjust_alloc_base_pointer called on thread-local static")
+                    panic!("adjust_alloc_root_pointer called on thread-local static")
                 }
                 Some(GlobalAlloc::Static(def_id)) if ecx.tcx.is_foreign_item(def_id) => {
-                    panic!("adjust_alloc_base_pointer called on extern static")
+                    panic!("adjust_alloc_root_pointer called on extern static")
                 }
                 _ => {}
             }
         }
         // FIXME: can we somehow preserve the immutability of `ptr`?
         let tag = if let Some(borrow_tracker) = &ecx.machine.borrow_tracker {
-            borrow_tracker.borrow_mut().base_ptr_tag(alloc_id, &ecx.machine)
+            borrow_tracker.borrow_mut().root_ptr_tag(alloc_id, &ecx.machine)
         } else {
             // Value does not matter, SB is disabled
             BorTag::default()
         };
-        ecx.adjust_alloc_base_pointer(ptr, tag, kind)
+        ecx.adjust_alloc_root_pointer(ptr, tag, kind)
     }
 
     /// Called on `usize as ptr` casts.
diff --git a/src/tools/miri/tests/fail/both_borrows/invalidate_against_protector3.stack.stderr b/src/tools/miri/tests/fail/both_borrows/invalidate_against_protector3.stack.stderr
index f6eeef33e9ee..8426f56004be 100644
--- a/src/tools/miri/tests/fail/both_borrows/invalidate_against_protector3.stack.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/invalidate_against_protector3.stack.stderr
@@ -6,7 +6,7 @@ LL |     unsafe { *x = 0 };
    |
    = help: this indicates a potential bug in the program: it performed an invalid operation, but the Stacked Borrows rules it violated are still experimental
    = help: see https://github.com/rust-lang/unsafe-code-guidelines/blob/master/wip/stacked-borrows.md for further information
-help: <TAG> was created here, as the base tag for ALLOC
+help: <TAG> was created here, as the root tag for ALLOC
   --> $DIR/invalidate_against_protector3.rs:LL:CC
    |
 LL |         let ptr = alloc(Layout::for_value(&0i32)) as *mut i32;

From 182698fef275b187b4e0bf68d9ab38061ce55ff0 Mon Sep 17 00:00:00 2001
From: Oli Scherer <git-spam-no-reply9815368754983@oli-obk.de>
Date: Wed, 17 Apr 2024 10:09:38 +0000
Subject: [PATCH 14/17] Don't error on subtyping of equal types

---
 compiler/rustc_infer/src/infer/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/rustc_infer/src/infer/mod.rs b/compiler/rustc_infer/src/infer/mod.rs
index 1dbf435e8c73..255e688fbc1d 100644
--- a/compiler/rustc_infer/src/infer/mod.rs
+++ b/compiler/rustc_infer/src/infer/mod.rs
@@ -952,7 +952,7 @@ impl<'tcx> InferCtxt<'tcx> {
             // a test for it.
             (_, ty::Infer(ty::TyVar(_))) => {}
             (ty::Infer(ty::TyVar(_)), _) => {}
-            _ if (r_a, r_b).has_opaque_types() => {
+            _ if r_a != r_b && (r_a, r_b).has_opaque_types() => {
                 span_bug!(
                     cause.span(),
                     "opaque types got hidden types registered from within subtype predicate: {r_a:?} vs {r_b:?}"

From 66a73f0c20b40eee93cdf5054358f6d1c78552c9 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Tue, 19 Mar 2024 10:04:32 +0000
Subject: [PATCH 15/17] Add regression test for #107495

---
 .../issue-107495-archive-permissions/foo.rs   |  1 +
 .../issue-107495-archive-permissions/rmake.rs | 22 +++++++++++++++++++
 2 files changed, 23 insertions(+)
 create mode 100644 tests/run-make/issue-107495-archive-permissions/foo.rs
 create mode 100644 tests/run-make/issue-107495-archive-permissions/rmake.rs

diff --git a/tests/run-make/issue-107495-archive-permissions/foo.rs b/tests/run-make/issue-107495-archive-permissions/foo.rs
new file mode 100644
index 000000000000..8b137891791f
--- /dev/null
+++ b/tests/run-make/issue-107495-archive-permissions/foo.rs
@@ -0,0 +1 @@
+
diff --git a/tests/run-make/issue-107495-archive-permissions/rmake.rs b/tests/run-make/issue-107495-archive-permissions/rmake.rs
new file mode 100644
index 000000000000..3076f49cc9f2
--- /dev/null
+++ b/tests/run-make/issue-107495-archive-permissions/rmake.rs
@@ -0,0 +1,22 @@
+extern crate run_make_support;
+
+use run_make_support::{aux_build, tmp_dir};
+use std::fs;
+#[cfg(unix)]
+use std::os::unix::fs::PermissionsExt;
+use std::path::Path;
+
+fn main() {
+    aux_build().arg("foo.rs").run();
+    verify(&tmp_dir().join("libfoo.rlib"));
+}
+
+fn verify(path: &Path) {
+    let perm = fs::metadata(path).unwrap().permissions();
+
+    assert!(!perm.readonly());
+
+    // Check that the file is readable for everyone
+    #[cfg(unix)]
+    assert_eq!(perm.mode(), 0o100664);
+}

From 297fceb9acc6895abf3379c4991a57b7178fa607 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Tue, 19 Mar 2024 10:10:47 +0000
Subject: [PATCH 16/17] Use the default file permissions when writing static
 libraries with ar_archive_writer

Fixes #107495
---
 .../rustc_codegen_ssa/src/back/archive.rs     | 27 +++++++++++++------
 .../issue-107495-archive-permissions/foo.rs   |  2 +-
 .../issue-107495-archive-permissions/rmake.rs |  9 +++++++
 3 files changed, 29 insertions(+), 9 deletions(-)

diff --git a/compiler/rustc_codegen_ssa/src/back/archive.rs b/compiler/rustc_codegen_ssa/src/back/archive.rs
index d336973d2b9c..c99118f5156d 100644
--- a/compiler/rustc_codegen_ssa/src/back/archive.rs
+++ b/compiler/rustc_codegen_ssa/src/back/archive.rs
@@ -13,7 +13,7 @@ use object::read::macho::FatArch;
 use tempfile::Builder as TempFileBuilder;
 
 use std::error::Error;
-use std::fs::File;
+use std::fs::{self, File};
 use std::io::{self, Write};
 use std::path::{Path, PathBuf};
 
@@ -280,12 +280,21 @@ impl<'a> ArArchiveBuilder<'a> {
         // This prevents programs (including rustc) from attempting to read a partial archive.
         // It also enables writing an archive with the same filename as a dependency on Windows as
         // required by a test.
-        let mut archive_tmpfile = TempFileBuilder::new()
+        // The tempfile crate currently uses 0o600 as mode for the temporary files and directories
+        // it creates. We need it to be the default mode for back compat reasons however. (See
+        // #107495) To handle this we are telling tempfile to create a temporary directory instead
+        // and then inside this directory create a file using File::create.
+        let archive_tmpdir = TempFileBuilder::new()
             .suffix(".temp-archive")
-            .tempfile_in(output.parent().unwrap_or_else(|| Path::new("")))
-            .map_err(|err| io_error_context("couldn't create a temp file", err))?;
+            .tempdir_in(output.parent().unwrap_or_else(|| Path::new("")))
+            .map_err(|err| {
+                io_error_context("couldn't create a directory for the temp file", err)
+            })?;
+        let archive_tmpfile_path = archive_tmpdir.path().join("tmp.a");
+        let mut archive_tmpfile = File::create_new(&archive_tmpfile_path)
+            .map_err(|err| io_error_context("couldn't create the temp file", err))?;
 
-        write_archive_to_stream(archive_tmpfile.as_file_mut(), &entries, archive_kind, false)?;
+        write_archive_to_stream(&mut archive_tmpfile, &entries, archive_kind, false)?;
 
         let any_entries = !entries.is_empty();
         drop(entries);
@@ -293,9 +302,11 @@ impl<'a> ArArchiveBuilder<'a> {
         // output archive to the same location as an input archive on Windows.
         drop(self.src_archives);
 
-        archive_tmpfile
-            .persist(output)
-            .map_err(|err| io_error_context("failed to rename archive file", err.error))?;
+        fs::rename(archive_tmpfile_path, output)
+            .map_err(|err| io_error_context("failed to rename archive file", err))?;
+        archive_tmpdir
+            .close()
+            .map_err(|err| io_error_context("failed to remove temporary directory", err))?;
 
         Ok(any_entries)
     }
diff --git a/tests/run-make/issue-107495-archive-permissions/foo.rs b/tests/run-make/issue-107495-archive-permissions/foo.rs
index 8b137891791f..d15abba59766 100644
--- a/tests/run-make/issue-107495-archive-permissions/foo.rs
+++ b/tests/run-make/issue-107495-archive-permissions/foo.rs
@@ -1 +1 @@
-
+// Empty
diff --git a/tests/run-make/issue-107495-archive-permissions/rmake.rs b/tests/run-make/issue-107495-archive-permissions/rmake.rs
index 3076f49cc9f2..40deabe15b73 100644
--- a/tests/run-make/issue-107495-archive-permissions/rmake.rs
+++ b/tests/run-make/issue-107495-archive-permissions/rmake.rs
@@ -1,3 +1,7 @@
+#![feature(rustc_private)]
+
+#[cfg(unix)]
+extern crate libc;
 extern crate run_make_support;
 
 use run_make_support::{aux_build, tmp_dir};
@@ -7,6 +11,11 @@ use std::os::unix::fs::PermissionsExt;
 use std::path::Path;
 
 fn main() {
+    #[cfg(unix)]
+    unsafe {
+        libc::umask(0o002);
+    }
+
     aux_build().arg("foo.rs").run();
     verify(&tmp_dir().join("libfoo.rlib"));
 }

From 6298d8f8fa304a28e6a12709c788060f4fedbcdb Mon Sep 17 00:00:00 2001
From: Ben Kimock <kimockb@gmail.com>
Date: Mon, 15 Apr 2024 23:46:27 -0400
Subject: [PATCH 17/17] Remove libc from rust_get_test_int uses

---
 tests/ui/abi/anon-extern-mod.rs               |  6 +----
 tests/ui/abi/c-stack-as-value.rs              |  6 +----
 .../anon-extern-mod-cross-crate-1.rs          |  5 +---
 tests/ui/abi/foreign/auxiliary/foreign_lib.rs | 24 +++++++++----------
 tests/ui/abi/foreign/foreign-dupe.rs          |  3 +--
 tests/ui/abi/foreign/foreign-no-abi.rs        | 21 ----------------
 tests/ui/attributes/item-attributes.rs        |  2 +-
 tests/ui/extern/issue-1251.rs                 |  5 +---
 8 files changed, 18 insertions(+), 54 deletions(-)
 delete mode 100644 tests/ui/abi/foreign/foreign-no-abi.rs

diff --git a/tests/ui/abi/anon-extern-mod.rs b/tests/ui/abi/anon-extern-mod.rs
index a424f93f637c..bb3739bc4afa 100644
--- a/tests/ui/abi/anon-extern-mod.rs
+++ b/tests/ui/abi/anon-extern-mod.rs
@@ -1,13 +1,9 @@
 //@ run-pass
 //@ pretty-expanded FIXME #23616
 
-#![feature(rustc_private)]
-
-extern crate libc;
-
 #[link(name = "rust_test_helpers", kind = "static")]
 extern "C" {
-    fn rust_get_test_int() -> libc::intptr_t;
+    fn rust_get_test_int() -> isize;
 }
 
 pub fn main() {
diff --git a/tests/ui/abi/c-stack-as-value.rs b/tests/ui/abi/c-stack-as-value.rs
index 6ea2051b05b3..401bc132b6e7 100644
--- a/tests/ui/abi/c-stack-as-value.rs
+++ b/tests/ui/abi/c-stack-as-value.rs
@@ -1,14 +1,10 @@
 //@ run-pass
 //@ pretty-expanded FIXME #23616
 
-#![feature(rustc_private)]
-
 mod rustrt {
-    extern crate libc;
-
     #[link(name = "rust_test_helpers", kind = "static")]
     extern "C" {
-        pub fn rust_get_test_int() -> libc::intptr_t;
+        pub fn rust_get_test_int() -> isize;
     }
 }
 
diff --git a/tests/ui/abi/cross-crate/auxiliary/anon-extern-mod-cross-crate-1.rs b/tests/ui/abi/cross-crate/auxiliary/anon-extern-mod-cross-crate-1.rs
index 5cbf8093c5c3..559c40546a8a 100644
--- a/tests/ui/abi/cross-crate/auxiliary/anon-extern-mod-cross-crate-1.rs
+++ b/tests/ui/abi/cross-crate/auxiliary/anon-extern-mod-cross-crate-1.rs
@@ -1,9 +1,6 @@
 #![crate_name = "anonexternmod"]
-#![feature(rustc_private)]
-
-extern crate libc;
 
 #[link(name = "rust_test_helpers", kind = "static")]
 extern "C" {
-    pub fn rust_get_test_int() -> libc::intptr_t;
+    pub fn rust_get_test_int() -> isize;
 }
diff --git a/tests/ui/abi/foreign/auxiliary/foreign_lib.rs b/tests/ui/abi/foreign/auxiliary/foreign_lib.rs
index 3c649b778bd1..74a95b96e9fc 100644
--- a/tests/ui/abi/foreign/auxiliary/foreign_lib.rs
+++ b/tests/ui/abi/foreign/auxiliary/foreign_lib.rs
@@ -1,28 +1,28 @@
 #![crate_name = "foreign_lib"]
-#![feature(rustc_private)]
 
 pub mod rustrt {
-    extern crate libc;
-
     #[link(name = "rust_test_helpers", kind = "static")]
     extern "C" {
-        pub fn rust_get_test_int() -> libc::intptr_t;
+        pub fn rust_get_test_int() -> isize;
     }
 }
 
 pub mod rustrt2 {
-    extern crate libc;
-
     extern "C" {
-        pub fn rust_get_test_int() -> libc::intptr_t;
+        pub fn rust_get_test_int() -> isize;
     }
 }
 
 pub mod rustrt3 {
-    // Different type, but same ABI (on all supported platforms).
-    // Ensures that we don't ICE or trigger LLVM asserts when
-    // importing the same symbol under different types.
-    // See https://github.com/rust-lang/rust/issues/32740.
+    // The point of this test is to ensure that we don't ICE or trigger LLVM asserts when importing
+    // the same symbol with different types. This is not really possible to test portably; there is
+    // no different signature we can come up with that is different to LLVM but which for sure has
+    // the same behavior on all platforms. The signed-ness of integers is ignored by LLVM as well
+    // as pointee types. So the only ways to make our signatures differ are to use
+    // differently-sized integers which is definitely an ABI mismatch, or to rely on pointers and
+    // isize/usize having the same ABI, which is wrong on CHERI and probably other niche platforms.
+    // If this test causes you trouble, please file an issue.
+    // See https://github.com/rust-lang/rust/issues/32740 for the bug that prompted this test.
     extern "C" {
         pub fn rust_get_test_int() -> *const u8;
     }
@@ -32,6 +32,6 @@ pub fn local_uses() {
     unsafe {
         let x = rustrt::rust_get_test_int();
         assert_eq!(x, rustrt2::rust_get_test_int());
-        assert_eq!(x as *const _, rustrt3::rust_get_test_int());
+        assert_eq!(x as *const u8, rustrt3::rust_get_test_int());
     }
 }
diff --git a/tests/ui/abi/foreign/foreign-dupe.rs b/tests/ui/abi/foreign/foreign-dupe.rs
index 1b6df0892c70..3473d436cb48 100644
--- a/tests/ui/abi/foreign/foreign-dupe.rs
+++ b/tests/ui/abi/foreign/foreign-dupe.rs
@@ -4,13 +4,12 @@
 // Check that we can still call duplicated extern (imported) functions
 // which were declared in another crate. See issues #32740 and #32783.
 
-
 extern crate foreign_lib;
 
 pub fn main() {
     unsafe {
         let x = foreign_lib::rustrt::rust_get_test_int();
         assert_eq!(x, foreign_lib::rustrt2::rust_get_test_int());
-        assert_eq!(x as *const _, foreign_lib::rustrt3::rust_get_test_int());
+        assert_eq!(x as *const u8, foreign_lib::rustrt3::rust_get_test_int());
     }
 }
diff --git a/tests/ui/abi/foreign/foreign-no-abi.rs b/tests/ui/abi/foreign/foreign-no-abi.rs
deleted file mode 100644
index 4ac47df29a71..000000000000
--- a/tests/ui/abi/foreign/foreign-no-abi.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-//@ run-pass
-// ABI is cdecl by default
-
-//@ pretty-expanded FIXME #23616
-
-#![feature(rustc_private)]
-
-mod rustrt {
-    extern crate libc;
-
-    #[link(name = "rust_test_helpers", kind = "static")]
-    extern "C" {
-        pub fn rust_get_test_int() -> libc::intptr_t;
-    }
-}
-
-pub fn main() {
-    unsafe {
-        rustrt::rust_get_test_int();
-    }
-}
diff --git a/tests/ui/attributes/item-attributes.rs b/tests/ui/attributes/item-attributes.rs
index 7fe7fdd97584..daab1bccb2c4 100644
--- a/tests/ui/attributes/item-attributes.rs
+++ b/tests/ui/attributes/item-attributes.rs
@@ -148,7 +148,7 @@ mod test_foreign_items {
             #![rustc_dummy]
 
             #[rustc_dummy]
-            fn rust_get_test_int() -> u32;
+            fn rust_get_test_int() -> isize;
         }
     }
 }
diff --git a/tests/ui/extern/issue-1251.rs b/tests/ui/extern/issue-1251.rs
index da2b8be7bc1f..5581bddaddc1 100644
--- a/tests/ui/extern/issue-1251.rs
+++ b/tests/ui/extern/issue-1251.rs
@@ -2,13 +2,10 @@
 #![allow(unused_attributes)]
 #![allow(dead_code)]
 //@ pretty-expanded FIXME #23616
-#![feature(rustc_private)]
 
 mod rustrt {
-    extern crate libc;
-
     extern "C" {
-        pub fn rust_get_test_int() -> libc::intptr_t;
+        pub fn rust_get_test_int() -> isize;
     }
 }