diff --git a/library/alloc/src/collections/vec_deque/mod.rs b/library/alloc/src/collections/vec_deque/mod.rs
index f8844e2d3a5cb..bd15a6a96f52c 100644
--- a/library/alloc/src/collections/vec_deque/mod.rs
+++ b/library/alloc/src/collections/vec_deque/mod.rs
@@ -9,7 +9,7 @@
 
 use core::cmp::{self, Ordering};
 use core::hash::{Hash, Hasher};
-use core::iter::{ByRefSized, repeat_n, repeat_with};
+use core::iter::{repeat_n, repeat_with};
 // This is used in a bunch of intra-doc links.
 // FIXME: For some reason, `#[cfg(doc)]` wasn't sufficient, resulting in
 // failures in linkchecker even though rustdoc built the docs just fine.
@@ -477,11 +477,7 @@ impl<T, A: Allocator> VecDeque<T, A> {
             unsafe { guard.deque.write_iter(dst, iter, &mut guard.written) };
         } else {
             unsafe {
-                guard.deque.write_iter(
-                    dst,
-                    ByRefSized(&mut iter).take(head_room),
-                    &mut guard.written,
-                );
+                guard.deque.write_iter(dst, (&mut iter).take(head_room), &mut guard.written);
                 guard.deque.write_iter(0, iter, &mut guard.written)
             };
         }
diff --git a/library/core/src/array/iter.rs b/library/core/src/array/iter.rs
index 1edade41597f7..3b4574c4e9544 100644
--- a/library/core/src/array/iter.rs
+++ b/library/core/src/array/iter.rs
@@ -260,7 +260,7 @@ impl<T, const N: usize> Iterator for IntoIter<T, N> {
         Fold: FnMut(Acc, Self::Item) -> Acc,
     {
         let data = &mut self.data;
-        iter::ByRefSized(&mut self.alive).fold(init, |acc, idx| {
+        (&mut self.alive).fold(init, |acc, idx| {
             // SAFETY: idx is obtained by folding over the `alive` range, which implies the
             // value is currently considered alive but as the range is being consumed each value
             // we read here will only be read once and then considered dead.
@@ -323,7 +323,7 @@ impl<T, const N: usize> DoubleEndedIterator for IntoIter<T, N> {
         Fold: FnMut(Acc, Self::Item) -> Acc,
     {
         let data = &mut self.data;
-        iter::ByRefSized(&mut self.alive).rfold(init, |acc, idx| {
+        (&mut self.alive).rfold(init, |acc, idx| {
             // SAFETY: idx is obtained by folding over the `alive` range, which implies the
             // value is currently considered alive but as the range is being consumed each value
             // we read here will only be read once and then considered dead.
diff --git a/library/core/src/iter/adapters/array_chunks.rs b/library/core/src/iter/adapters/array_chunks.rs
index 8f1744fc5fbb7..ca1a0a67ff8e5 100644
--- a/library/core/src/iter/adapters/array_chunks.rs
+++ b/library/core/src/iter/adapters/array_chunks.rs
@@ -1,8 +1,6 @@
 use crate::array;
 use crate::iter::adapters::SourceIter;
-use crate::iter::{
-    ByRefSized, FusedIterator, InPlaceIterable, TrustedFused, TrustedRandomAccessNoCoerce,
-};
+use crate::iter::{FusedIterator, InPlaceIterable, TrustedFused, TrustedRandomAccessNoCoerce};
 use crate::num::NonZero;
 use crate::ops::{ControlFlow, NeverShortCircuit, Try};
 
@@ -128,7 +126,7 @@ where
         self.next_back_remainder();
 
         let mut acc = init;
-        let mut iter = ByRefSized(&mut self.iter).rev();
+        let mut iter = (&mut self.iter).rev();
 
         // NB remainder is handled by `next_back_remainder`, so
         // `next_chunk` can't return `Err` with non-empty remainder
diff --git a/library/core/src/iter/adapters/by_ref.rs b/library/core/src/iter/adapters/by_ref.rs
new file mode 100644
index 0000000000000..d7b105e7dac0b
--- /dev/null
+++ b/library/core/src/iter/adapters/by_ref.rs
@@ -0,0 +1,554 @@
+use crate::array;
+use crate::iter::{FusedIterator, TrustedLen};
+use crate::num::NonZero;
+use crate::ops::{ChangeOutputType, NeverShortCircuit, Residual, Try};
+
+/// Implements `Iterator` for mutable references to iterators, such as those produced by [`Iterator::by_ref`].
+///
+/// This implementation passes all method calls on to the original iterator.
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<I: Iterator + ?Sized> Iterator for &mut I {
+    type Item = I::Item;
+
+    #[inline]
+    fn next(&mut self) -> Option<Self::Item> {
+        ByRef::<I>(self).next()
+    }
+
+    fn next_chunk<const N: usize>(
+        &mut self,
+    ) -> Result<[Self::Item; N], array::IntoIter<Self::Item, N>> {
+        ByRef::<I>(self).next_chunk()
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        I::size_hint(self)
+    }
+
+    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
+        ByRef::<I>(self).advance_by(n)
+    }
+
+    fn nth(&mut self, n: usize) -> Option<Self::Item> {
+        ByRef::<I>(self).nth(n)
+    }
+
+    fn for_each<F>(self, f: F)
+    where
+        F: FnMut(Self::Item),
+    {
+        ByRef::<I>(self).for_each(f)
+    }
+
+    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
+    where
+        F: FnMut(B, Self::Item) -> R,
+        R: Try<Output = B>,
+    {
+        ByRef::<I>(self).try_fold(init, f)
+    }
+
+    fn try_for_each<F, R>(&mut self, f: F) -> R
+    where
+        F: FnMut(Self::Item) -> R,
+        R: Try<Output = ()>,
+    {
+        ByRef::<I>(self).try_for_each(f)
+    }
+
+    fn fold<B, F>(self, init: B, f: F) -> B
+    where
+        F: FnMut(B, Self::Item) -> B,
+    {
+        ByRef::<I>(self).fold(init, f)
+    }
+
+    fn reduce<F>(self, f: F) -> Option<Self::Item>
+    where
+        F: FnMut(Self::Item, Self::Item) -> Self::Item,
+    {
+        ByRef::<I>(self).reduce(f)
+    }
+
+    fn try_reduce<R>(
+        &mut self,
+        f: impl FnMut(Self::Item, Self::Item) -> R,
+    ) -> ChangeOutputType<R, Option<R::Output>>
+    where
+        R: Try<Output = Self::Item, Residual: Residual<Option<Self::Item>>>,
+    {
+        ByRef::<I>(self).try_reduce(f)
+    }
+
+    fn all<F>(&mut self, f: F) -> bool
+    where
+        F: FnMut(Self::Item) -> bool,
+    {
+        ByRef::<I>(self).all(f)
+    }
+
+    fn any<F>(&mut self, f: F) -> bool
+    where
+        F: FnMut(Self::Item) -> bool,
+    {
+        ByRef::<I>(self).any(f)
+    }
+
+    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
+    where
+        P: FnMut(&Self::Item) -> bool,
+    {
+        ByRef::<I>(self).find(predicate)
+    }
+
+    fn find_map<B, F>(&mut self, f: F) -> Option<B>
+    where
+        F: FnMut(Self::Item) -> Option<B>,
+    {
+        ByRef::<I>(self).find_map(f)
+    }
+
+    fn try_find<R>(
+        &mut self,
+        f: impl FnMut(&Self::Item) -> R,
+    ) -> ChangeOutputType<R, Option<Self::Item>>
+    where
+        R: Try<Output = bool, Residual: Residual<Option<Self::Item>>>,
+    {
+        ByRef::<I>(self).try_find(f)
+    }
+
+    fn position<P>(&mut self, predicate: P) -> Option<usize>
+    where
+        P: FnMut(Self::Item) -> bool,
+    {
+        ByRef::<I>(self).position(predicate)
+    }
+
+    // FIXME: also specialize rposition
+    //
+    // Unfortunately, it's not possible to infer
+    //
+    // `I: DoubleEndedIterator + ExactSizeIterator`
+    //
+    // from
+    //
+    // `&mut I: DoubleEndedIterator + ExactSizeIterator`
+    //
+    // which makes it impossible to call the inner `rposition`, even with
+    // specialization.
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<I: DoubleEndedIterator + ?Sized> DoubleEndedIterator for &mut I {
+    fn next_back(&mut self) -> Option<Self::Item> {
+        ByRef::<I>(self).next_back()
+    }
+
+    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
+        ByRef::<I>(self).advance_back_by(n)
+    }
+
+    fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
+        ByRef::<I>(self).nth_back(n)
+    }
+
+    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
+    where
+        F: FnMut(B, Self::Item) -> R,
+        R: Try<Output = B>,
+    {
+        ByRef::<I>(self).try_rfold(init, f)
+    }
+
+    fn rfold<B, F>(self, init: B, f: F) -> B
+    where
+        F: FnMut(B, Self::Item) -> B,
+    {
+        ByRef::<I>(self).rfold(init, f)
+    }
+
+    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
+    where
+        P: FnMut(&Self::Item) -> bool,
+    {
+        ByRef::<I>(self).rfind(predicate)
+    }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<I: ExactSizeIterator + ?Sized> ExactSizeIterator for &mut I {
+    fn len(&self) -> usize {
+        I::len(self)
+    }
+
+    fn is_empty(&self) -> bool {
+        I::is_empty(self)
+    }
+}
+
+#[stable(feature = "fused", since = "1.26.0")]
+impl<I: FusedIterator + ?Sized> FusedIterator for &mut I {}
+
+#[unstable(feature = "trusted_len", issue = "37572")]
+unsafe impl<I: TrustedLen + ?Sized> TrustedLen for &mut I {}
+
+// The following implementations use UFCS-style, rather than trusting autoderef,
+// to avoid accidentally calling the `&mut Iterator` implementations.
+
+/// A helper struct that implements all overridden `Iterator` methods by
+/// forwarding them to either [`ByRefDefault`] or the underlying iterator.
+///
+/// It's `std`'s policy to not expose specialization publicly, hence we do not
+/// specialize the public `Iterator for &mut I` implementation but only the
+/// `Iterator` implementation of this private helper struct.
+struct ByRef<'a, I: ?Sized>(&'a mut I);
+
+// Make sure to add all iterator methods that can be forwarded in any way to
+// a `Sized` underlying iterator here. Sometimes, e.g. in the case of `fold`
+// that can involve going through the fallible version of a functions, since
+// they mostly take a reference instead of consuming the iterator.
+impl<I: Iterator + ?Sized> Iterator for ByRef<'_, I> {
+    type Item = I::Item;
+
+    #[inline]
+    fn next(&mut self) -> Option<Self::Item> {
+        ByRefDefault::<I>(self.0).next()
+    }
+
+    default fn next_chunk<const N: usize>(
+        &mut self,
+    ) -> Result<[Self::Item; N], array::IntoIter<Self::Item, N>> {
+        ByRefDefault::<I>(self.0).next_chunk()
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        I::size_hint(self.0)
+    }
+
+    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
+        ByRefDefault::<I>(self.0).advance_by(n)
+    }
+
+    fn nth(&mut self, n: usize) -> Option<Self::Item> {
+        ByRefDefault::<I>(self.0).nth(n)
+    }
+
+    default fn for_each<F>(self, f: F)
+    where
+        F: FnMut(Self::Item),
+    {
+        ByRefDefault::<I>(self.0).for_each(f);
+    }
+
+    default fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
+    where
+        F: FnMut(B, Self::Item) -> R,
+        R: Try<Output = B>,
+    {
+        ByRefDefault::<I>(self.0).try_fold(init, f)
+    }
+
+    default fn try_for_each<F, R>(&mut self, f: F) -> R
+    where
+        F: FnMut(Self::Item) -> R,
+        R: Try<Output = ()>,
+    {
+        ByRefDefault::<I>(self.0).try_for_each(f)
+    }
+
+    default fn fold<B, F>(self, init: B, f: F) -> B
+    where
+        F: FnMut(B, Self::Item) -> B,
+    {
+        ByRefDefault::<I>(self.0).fold(init, f)
+    }
+
+    default fn reduce<F>(self, f: F) -> Option<Self::Item>
+    where
+        F: FnMut(Self::Item, Self::Item) -> Self::Item,
+    {
+        ByRefDefault::<I>(self.0).reduce(f)
+    }
+
+    default fn try_reduce<R>(
+        &mut self,
+        f: impl FnMut(Self::Item, Self::Item) -> R,
+    ) -> ChangeOutputType<R, Option<R::Output>>
+    where
+        R: Try<Output = Self::Item, Residual: Residual<Option<Self::Item>>>,
+    {
+        ByRefDefault::<I>(self.0).try_reduce(f)
+    }
+
+    default fn all<F>(&mut self, f: F) -> bool
+    where
+        F: FnMut(Self::Item) -> bool,
+    {
+        ByRefDefault::<I>(self.0).all(f)
+    }
+
+    default fn any<F>(&mut self, f: F) -> bool
+    where
+        F: FnMut(Self::Item) -> bool,
+    {
+        ByRefDefault::<I>(self.0).any(f)
+    }
+
+    default fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
+    where
+        P: FnMut(&Self::Item) -> bool,
+    {
+        ByRefDefault::<I>(self.0).find(predicate)
+    }
+
+    default fn find_map<B, F>(&mut self, f: F) -> Option<B>
+    where
+        F: FnMut(Self::Item) -> Option<B>,
+    {
+        ByRefDefault::<I>(self.0).find_map(f)
+    }
+
+    default fn try_find<R>(
+        &mut self,
+        f: impl FnMut(&Self::Item) -> R,
+    ) -> ChangeOutputType<R, Option<Self::Item>>
+    where
+        R: Try<Output = bool, Residual: Residual<Option<Self::Item>>>,
+    {
+        ByRefDefault::<I>(self.0).try_find(f)
+    }
+
+    default fn position<P>(&mut self, predicate: P) -> Option<usize>
+    where
+        P: FnMut(Self::Item) -> bool,
+    {
+        ByRefDefault::<I>(self.0).position(predicate)
+    }
+}
+
+impl<I: Iterator> Iterator for ByRef<'_, I> {
+    fn next_chunk<const N: usize>(
+        &mut self,
+    ) -> Result<[Self::Item; N], array::IntoIter<Self::Item, N>> {
+        I::next_chunk(self.0)
+    }
+
+    fn for_each<F>(self, f: F)
+    where
+        F: FnMut(Self::Item),
+    {
+        I::try_for_each(self.0, NeverShortCircuit::wrap_mut_1(f)).0
+    }
+
+    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
+    where
+        F: FnMut(B, Self::Item) -> R,
+        R: Try<Output = B>,
+    {
+        I::try_fold(self.0, init, f)
+    }
+
+    fn try_for_each<F, R>(&mut self, f: F) -> R
+    where
+        F: FnMut(Self::Item) -> R,
+        R: Try<Output = ()>,
+    {
+        I::try_for_each(self.0, f)
+    }
+
+    fn fold<B, F>(self, init: B, f: F) -> B
+    where
+        F: FnMut(B, Self::Item) -> B,
+    {
+        I::try_fold(self.0, init, NeverShortCircuit::wrap_mut_2(f)).0
+    }
+
+    fn reduce<F>(self, f: F) -> Option<Self::Item>
+    where
+        F: FnMut(Self::Item, Self::Item) -> Self::Item,
+    {
+        I::try_reduce(self.0, NeverShortCircuit::wrap_mut_2(f)).0
+    }
+
+    fn try_reduce<R>(
+        &mut self,
+        f: impl FnMut(Self::Item, Self::Item) -> R,
+    ) -> ChangeOutputType<R, Option<R::Output>>
+    where
+        R: Try<Output = Self::Item, Residual: Residual<Option<Self::Item>>>,
+    {
+        I::try_reduce(self.0, f)
+    }
+
+    fn all<F>(&mut self, f: F) -> bool
+    where
+        F: FnMut(Self::Item) -> bool,
+    {
+        I::all(self.0, f)
+    }
+
+    fn any<F>(&mut self, f: F) -> bool
+    where
+        F: FnMut(Self::Item) -> bool,
+    {
+        I::any(self.0, f)
+    }
+
+    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
+    where
+        P: FnMut(&Self::Item) -> bool,
+    {
+        I::find(self.0, predicate)
+    }
+
+    fn find_map<B, F>(&mut self, f: F) -> Option<B>
+    where
+        F: FnMut(Self::Item) -> Option<B>,
+    {
+        I::find_map(self.0, f)
+    }
+
+    fn try_find<R>(
+        &mut self,
+        f: impl FnMut(&Self::Item) -> R,
+    ) -> ChangeOutputType<R, Option<Self::Item>>
+    where
+        R: Try<Output = bool, Residual: Residual<Option<Self::Item>>>,
+    {
+        I::try_find(self.0, f)
+    }
+
+    fn position<P>(&mut self, predicate: P) -> Option<usize>
+    where
+        P: FnMut(Self::Item) -> bool,
+    {
+        I::position(self.0, predicate)
+    }
+}
+
+impl<I: DoubleEndedIterator + ?Sized> DoubleEndedIterator for ByRef<'_, I> {
+    fn next_back(&mut self) -> Option<Self::Item> {
+        ByRefDefault::<I>(self.0).next_back()
+    }
+
+    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
+        ByRefDefault::<I>(self.0).advance_back_by(n)
+    }
+
+    fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
+        ByRefDefault::<I>(self.0).nth_back(n)
+    }
+
+    default fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
+    where
+        F: FnMut(B, Self::Item) -> R,
+        R: Try<Output = B>,
+    {
+        ByRefDefault::<I>(self.0).try_rfold(init, f)
+    }
+
+    default fn rfold<B, F>(self, init: B, f: F) -> B
+    where
+        F: FnMut(B, Self::Item) -> B,
+    {
+        ByRefDefault::<I>(self.0).rfold(init, f)
+    }
+
+    default fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
+    where
+        P: FnMut(&Self::Item) -> bool,
+    {
+        ByRefDefault::<I>(self.0).rfind(predicate)
+    }
+}
+
+impl<I: DoubleEndedIterator> DoubleEndedIterator for ByRef<'_, I> {
+    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
+    where
+        F: FnMut(B, Self::Item) -> R,
+        R: Try<Output = B>,
+    {
+        I::try_rfold(self.0, init, f)
+    }
+
+    fn rfold<B, F>(self, init: B, f: F) -> B
+    where
+        F: FnMut(B, Self::Item) -> B,
+    {
+        I::try_rfold(self.0, init, NeverShortCircuit::wrap_mut_2(f)).0
+    }
+
+    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
+    where
+        P: FnMut(&Self::Item) -> bool,
+    {
+        I::rfind(self.0, predicate)
+    }
+}
+
+impl<I: ExactSizeIterator + ?Sized> ExactSizeIterator for ByRef<'_, I> {
+    fn len(&self) -> usize {
+        I::len(self.0)
+    }
+
+    fn is_empty(&self) -> bool {
+        I::is_empty(self.0)
+    }
+}
+
+impl<I: FusedIterator + ?Sized> FusedIterator for ByRef<'_, I> {}
+unsafe impl<I: TrustedLen + ?Sized> TrustedLen for ByRef<'_, I> {}
+
+/// This struct implements `Iterator` the "naive" way without specialization,
+/// which is used to access the default implementations of the iterator methods.
+struct ByRefDefault<'a, I: ?Sized>(&'a mut I);
+
+// Make sure to add all iterator methods that can be directly forwarded here.
+impl<I: Iterator + ?Sized> Iterator for ByRefDefault<'_, I> {
+    type Item = I::Item;
+
+    #[inline]
+    fn next(&mut self) -> Option<Self::Item> {
+        I::next(self.0)
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        I::size_hint(self.0)
+    }
+
+    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
+        I::advance_by(self.0, n)
+    }
+
+    fn nth(&mut self, n: usize) -> Option<Self::Item> {
+        I::nth(self.0, n)
+    }
+}
+
+impl<I: DoubleEndedIterator + ?Sized> DoubleEndedIterator for ByRefDefault<'_, I> {
+    fn next_back(&mut self) -> Option<Self::Item> {
+        I::next_back(self.0)
+    }
+
+    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
+        I::advance_back_by(self.0, n)
+    }
+
+    fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
+        I::nth_back(self.0, n)
+    }
+}
+
+impl<I: ExactSizeIterator + ?Sized> ExactSizeIterator for ByRefDefault<'_, I> {
+    fn len(&self) -> usize {
+        I::len(self.0)
+    }
+
+    fn is_empty(&self) -> bool {
+        I::is_empty(self.0)
+    }
+}
+
+impl<I: FusedIterator + ?Sized> FusedIterator for ByRefDefault<'_, I> {}
+unsafe impl<I: TrustedLen + ?Sized> TrustedLen for ByRefDefault<'_, I> {}
diff --git a/library/core/src/iter/adapters/by_ref_sized.rs b/library/core/src/iter/adapters/by_ref_sized.rs
deleted file mode 100644
index d084bede1eba6..0000000000000
--- a/library/core/src/iter/adapters/by_ref_sized.rs
+++ /dev/null
@@ -1,92 +0,0 @@
-use crate::num::NonZero;
-use crate::ops::{NeverShortCircuit, Try};
-
-/// Like `Iterator::by_ref`, but requiring `Sized` so it can forward generics.
-///
-/// Ideally this will no longer be required, eventually, but as can be seen in
-/// the benchmarks (as of Feb 2022 at least) `by_ref` can have performance cost.
-#[unstable(feature = "std_internals", issue = "none")]
-#[derive(Debug)]
-pub struct ByRefSized<'a, I>(pub &'a mut I);
-
-// The following implementations use UFCS-style, rather than trusting autoderef,
-// to avoid accidentally calling the `&mut Iterator` implementations.
-
-#[unstable(feature = "std_internals", issue = "none")]
-impl<I: Iterator> Iterator for ByRefSized<'_, I> {
-    type Item = I::Item;
-
-    #[inline]
-    fn next(&mut self) -> Option<Self::Item> {
-        I::next(self.0)
-    }
-
-    #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        I::size_hint(self.0)
-    }
-
-    #[inline]
-    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
-        I::advance_by(self.0, n)
-    }
-
-    #[inline]
-    fn nth(&mut self, n: usize) -> Option<Self::Item> {
-        I::nth(self.0, n)
-    }
-
-    #[inline]
-    fn fold<B, F>(self, init: B, f: F) -> B
-    where
-        F: FnMut(B, Self::Item) -> B,
-    {
-        // `fold` needs ownership, so this can't forward directly.
-        I::try_fold(self.0, init, NeverShortCircuit::wrap_mut_2(f)).0
-    }
-
-    #[inline]
-    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
-    where
-        F: FnMut(B, Self::Item) -> R,
-        R: Try<Output = B>,
-    {
-        I::try_fold(self.0, init, f)
-    }
-}
-
-#[unstable(feature = "std_internals", issue = "none")]
-impl<I: DoubleEndedIterator> DoubleEndedIterator for ByRefSized<'_, I> {
-    #[inline]
-    fn next_back(&mut self) -> Option<Self::Item> {
-        I::next_back(self.0)
-    }
-
-    #[inline]
-    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
-        I::advance_back_by(self.0, n)
-    }
-
-    #[inline]
-    fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
-        I::nth_back(self.0, n)
-    }
-
-    #[inline]
-    fn rfold<B, F>(self, init: B, f: F) -> B
-    where
-        F: FnMut(B, Self::Item) -> B,
-    {
-        // `rfold` needs ownership, so this can't forward directly.
-        I::try_rfold(self.0, init, NeverShortCircuit::wrap_mut_2(f)).0
-    }
-
-    #[inline]
-    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
-    where
-        F: FnMut(B, Self::Item) -> R,
-        R: Try<Output = B>,
-    {
-        I::try_rfold(self.0, init, f)
-    }
-}
diff --git a/library/core/src/iter/adapters/mod.rs b/library/core/src/iter/adapters/mod.rs
index 2a0ef0189d165..5c58620e7dbab 100644
--- a/library/core/src/iter/adapters/mod.rs
+++ b/library/core/src/iter/adapters/mod.rs
@@ -3,7 +3,7 @@ use crate::num::NonZero;
 use crate::ops::{ChangeOutputType, ControlFlow, FromResidual, Residual, Try};
 
 mod array_chunks;
-mod by_ref_sized;
+mod by_ref;
 mod chain;
 mod cloned;
 mod copied;
@@ -30,8 +30,6 @@ mod zip;
 
 #[unstable(feature = "iter_array_chunks", reason = "recently added", issue = "100450")]
 pub use self::array_chunks::ArrayChunks;
-#[unstable(feature = "std_internals", issue = "none")]
-pub use self::by_ref_sized::ByRefSized;
 #[unstable(feature = "iter_chain", reason = "recently added", issue = "125964")]
 pub use self::chain::chain;
 #[stable(feature = "iter_cloned", since = "1.1.0")]
diff --git a/library/core/src/iter/mod.rs b/library/core/src/iter/mod.rs
index d62a445d704ae..a12927d397f8a 100644
--- a/library/core/src/iter/mod.rs
+++ b/library/core/src/iter/mod.rs
@@ -382,8 +382,6 @@ macro_rules! impl_fold_via_try_fold {
 
 #[unstable(feature = "iter_array_chunks", reason = "recently added", issue = "100450")]
 pub use self::adapters::ArrayChunks;
-#[unstable(feature = "std_internals", issue = "none")]
-pub use self::adapters::ByRefSized;
 #[stable(feature = "iter_cloned", since = "1.1.0")]
 pub use self::adapters::Cloned;
 #[stable(feature = "iter_copied", since = "1.36.0")]
diff --git a/library/core/src/iter/traits/double_ended.rs b/library/core/src/iter/traits/double_ended.rs
index 7dabaece95561..9dca92b20b9ec 100644
--- a/library/core/src/iter/traits/double_ended.rs
+++ b/library/core/src/iter/traits/double_ended.rs
@@ -368,78 +368,3 @@ pub trait DoubleEndedIterator: Iterator {
         self.try_rfold((), check(predicate)).break_value()
     }
 }
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, I: DoubleEndedIterator + ?Sized> DoubleEndedIterator for &'a mut I {
-    fn next_back(&mut self) -> Option<I::Item> {
-        (**self).next_back()
-    }
-    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
-        (**self).advance_back_by(n)
-    }
-    fn nth_back(&mut self, n: usize) -> Option<I::Item> {
-        (**self).nth_back(n)
-    }
-    fn rfold<B, F>(self, init: B, f: F) -> B
-    where
-        F: FnMut(B, Self::Item) -> B,
-    {
-        self.spec_rfold(init, f)
-    }
-    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
-    where
-        F: FnMut(B, Self::Item) -> R,
-        R: Try<Output = B>,
-    {
-        self.spec_try_rfold(init, f)
-    }
-}
-
-/// Helper trait to specialize `rfold` and `rtry_fold` for `&mut I where I: Sized`
-trait DoubleEndedIteratorRefSpec: DoubleEndedIterator {
-    fn spec_rfold<B, F>(self, init: B, f: F) -> B
-    where
-        F: FnMut(B, Self::Item) -> B;
-
-    fn spec_try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
-    where
-        F: FnMut(B, Self::Item) -> R,
-        R: Try<Output = B>;
-}
-
-impl<I: DoubleEndedIterator + ?Sized> DoubleEndedIteratorRefSpec for &mut I {
-    default fn spec_rfold<B, F>(self, init: B, mut f: F) -> B
-    where
-        F: FnMut(B, Self::Item) -> B,
-    {
-        let mut accum = init;
-        while let Some(x) = self.next_back() {
-            accum = f(accum, x);
-        }
-        accum
-    }
-
-    default fn spec_try_rfold<B, F, R>(&mut self, init: B, mut f: F) -> R
-    where
-        F: FnMut(B, Self::Item) -> R,
-        R: Try<Output = B>,
-    {
-        let mut accum = init;
-        while let Some(x) = self.next_back() {
-            accum = f(accum, x)?;
-        }
-        try { accum }
-    }
-}
-
-impl<I: DoubleEndedIterator> DoubleEndedIteratorRefSpec for &mut I {
-    impl_fold_via_try_fold! { spec_rfold -> spec_try_rfold }
-
-    fn spec_try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
-    where
-        F: FnMut(B, Self::Item) -> R,
-        R: Try<Output = B>,
-    {
-        (**self).try_rfold(init, f)
-    }
-}
diff --git a/library/core/src/iter/traits/exact_size.rs b/library/core/src/iter/traits/exact_size.rs
index 908830d8a9514..6e5df8d2379c4 100644
--- a/library/core/src/iter/traits/exact_size.rs
+++ b/library/core/src/iter/traits/exact_size.rs
@@ -149,13 +149,3 @@ pub trait ExactSizeIterator: Iterator {
         self.len() == 0
     }
 }
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<I: ExactSizeIterator + ?Sized> ExactSizeIterator for &mut I {
-    fn len(&self) -> usize {
-        (**self).len()
-    }
-    fn is_empty(&self) -> bool {
-        (**self).is_empty()
-    }
-}
diff --git a/library/core/src/iter/traits/iterator.rs b/library/core/src/iter/traits/iterator.rs
index 3bbb52fdbcb5f..6d6b9f498feb2 100644
--- a/library/core/src/iter/traits/iterator.rs
+++ b/library/core/src/iter/traits/iterator.rs
@@ -1,8 +1,8 @@
 use super::super::{
-    ArrayChunks, ByRefSized, Chain, Cloned, Copied, Cycle, Enumerate, Filter, FilterMap, FlatMap,
-    Flatten, Fuse, Inspect, Intersperse, IntersperseWith, Map, MapWhile, MapWindows, Peekable,
-    Product, Rev, Scan, Skip, SkipWhile, StepBy, Sum, Take, TakeWhile, TrustedRandomAccessNoCoerce,
-    Zip, try_process,
+    ArrayChunks, Chain, Cloned, Copied, Cycle, Enumerate, Filter, FilterMap, FlatMap, Flatten,
+    Fuse, Inspect, Intersperse, IntersperseWith, Map, MapWhile, MapWindows, Peekable, Product, Rev,
+    Scan, Skip, SkipWhile, StepBy, Sum, Take, TakeWhile, TrustedRandomAccessNoCoerce, Zip,
+    try_process,
 };
 use crate::array;
 use crate::cmp::{self, Ordering};
@@ -2062,7 +2062,7 @@ pub trait Iterator {
         Self::Item: Try<Residual: Residual<B>>,
         B: FromIterator<<Self::Item as Try>::Output>,
     {
-        try_process(ByRefSized(self), |i| i.collect())
+        try_process(self, |i| i.collect())
     }
 
     /// Collects all the items from an iterator into a collection.
@@ -4037,86 +4037,3 @@ where
         ControlFlow::Break(x) => x,
     }
 }
-
-/// Implements `Iterator` for mutable references to iterators, such as those produced by [`Iterator::by_ref`].
-///
-/// This implementation passes all method calls on to the original iterator.
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<I: Iterator + ?Sized> Iterator for &mut I {
-    type Item = I::Item;
-    #[inline]
-    fn next(&mut self) -> Option<I::Item> {
-        (**self).next()
-    }
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        (**self).size_hint()
-    }
-    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
-        (**self).advance_by(n)
-    }
-    fn nth(&mut self, n: usize) -> Option<Self::Item> {
-        (**self).nth(n)
-    }
-    fn fold<B, F>(self, init: B, f: F) -> B
-    where
-        F: FnMut(B, Self::Item) -> B,
-    {
-        self.spec_fold(init, f)
-    }
-    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
-    where
-        F: FnMut(B, Self::Item) -> R,
-        R: Try<Output = B>,
-    {
-        self.spec_try_fold(init, f)
-    }
-}
-
-/// Helper trait to specialize `fold` and `try_fold` for `&mut I where I: Sized`
-trait IteratorRefSpec: Iterator {
-    fn spec_fold<B, F>(self, init: B, f: F) -> B
-    where
-        F: FnMut(B, Self::Item) -> B;
-
-    fn spec_try_fold<B, F, R>(&mut self, init: B, f: F) -> R
-    where
-        F: FnMut(B, Self::Item) -> R,
-        R: Try<Output = B>;
-}
-
-impl<I: Iterator + ?Sized> IteratorRefSpec for &mut I {
-    default fn spec_fold<B, F>(self, init: B, mut f: F) -> B
-    where
-        F: FnMut(B, Self::Item) -> B,
-    {
-        let mut accum = init;
-        while let Some(x) = self.next() {
-            accum = f(accum, x);
-        }
-        accum
-    }
-
-    default fn spec_try_fold<B, F, R>(&mut self, init: B, mut f: F) -> R
-    where
-        F: FnMut(B, Self::Item) -> R,
-        R: Try<Output = B>,
-    {
-        let mut accum = init;
-        while let Some(x) = self.next() {
-            accum = f(accum, x)?;
-        }
-        try { accum }
-    }
-}
-
-impl<I: Iterator> IteratorRefSpec for &mut I {
-    impl_fold_via_try_fold! { spec_fold -> spec_try_fold }
-
-    fn spec_try_fold<B, F, R>(&mut self, init: B, f: F) -> R
-    where
-        F: FnMut(B, Self::Item) -> R,
-        R: Try<Output = B>,
-    {
-        (**self).try_fold(init, f)
-    }
-}
diff --git a/library/core/src/iter/traits/marker.rs b/library/core/src/iter/traits/marker.rs
index 2e756a6dd67c4..7042b48a91486 100644
--- a/library/core/src/iter/traits/marker.rs
+++ b/library/core/src/iter/traits/marker.rs
@@ -31,9 +31,6 @@ pub unsafe trait TrustedFused {}
 #[lang = "fused_iterator"]
 pub trait FusedIterator: Iterator {}
 
-#[stable(feature = "fused", since = "1.26.0")]
-impl<I: FusedIterator + ?Sized> FusedIterator for &mut I {}
-
 /// An iterator that reports an accurate length using size_hint.
 ///
 /// The iterator reports a size hint where it is either exact
@@ -65,9 +62,6 @@ impl<I: FusedIterator + ?Sized> FusedIterator for &mut I {}
 #[rustc_unsafe_specialization_marker]
 pub unsafe trait TrustedLen: Iterator {}
 
-#[unstable(feature = "trusted_len", issue = "37572")]
-unsafe impl<I: TrustedLen + ?Sized> TrustedLen for &mut I {}
-
 /// An iterator that when yielding an item will have taken at least one element
 /// from its underlying [`SourceIter`].
 ///
diff --git a/library/coretests/tests/iter/adapters/by_ref_sized.rs b/library/coretests/tests/iter/adapters/by_ref.rs
similarity index 57%
rename from library/coretests/tests/iter/adapters/by_ref_sized.rs
rename to library/coretests/tests/iter/adapters/by_ref.rs
index a9c066f0e8cb1..92558906d512f 100644
--- a/library/coretests/tests/iter/adapters/by_ref_sized.rs
+++ b/library/coretests/tests/iter/adapters/by_ref.rs
@@ -1,20 +1,18 @@
-use core::iter::*;
-
 #[test]
 fn test_iterator_by_ref_sized() {
     let a = ['a', 'b', 'c', 'd'];
 
     let mut s = String::from("Z");
     let mut it = a.iter().copied();
-    ByRefSized(&mut it).take(2).for_each(|x| s.push(x));
+    (&mut it).take(2).for_each(|x| s.push(x));
     assert_eq!(s, "Zab");
-    ByRefSized(&mut it).fold((), |(), x| s.push(x));
+    (&mut it).fold((), |(), x| s.push(x));
     assert_eq!(s, "Zabcd");
 
     let mut s = String::from("Z");
     let mut it = a.iter().copied();
-    ByRefSized(&mut it).rev().take(2).for_each(|x| s.push(x));
+    (&mut it).rev().take(2).for_each(|x| s.push(x));
     assert_eq!(s, "Zdc");
-    ByRefSized(&mut it).rfold((), |(), x| s.push(x));
+    (&mut it).rfold((), |(), x| s.push(x));
     assert_eq!(s, "Zdcba");
 }
diff --git a/library/coretests/tests/iter/adapters/mod.rs b/library/coretests/tests/iter/adapters/mod.rs
index dedb4c0a9dd5f..a89787ab85c97 100644
--- a/library/coretests/tests/iter/adapters/mod.rs
+++ b/library/coretests/tests/iter/adapters/mod.rs
@@ -1,5 +1,5 @@
 mod array_chunks;
-mod by_ref_sized;
+mod by_ref;
 mod chain;
 mod cloned;
 mod copied;