Reduce API surface of Buffer

None of the currently public methods are accessible outside `std`, and are unused within. Therefore, they can be restricted to internal use.

Author: bushrat011899

library/alloc/src/io/buffered/bufreader/buffer.rs

@@ -15,7 +15,9 @@ use core::mem::MaybeUninit;
 use crate::boxed::Box;
 use crate::io::{self, BorrowedBuf, ErrorKind, Read};
 
-#[expect(missing_debug_implementations)]
+#[doc(hidden)]
+#[unstable(feature = "core_io_internals", reason = "exposed only for libstd", issue = "none")]
+#[derive(Debug)]
 pub struct Buffer {
     // The buffer.
     buf: Box<[MaybeUninit<u8>]>,
@@ -34,15 +36,13 @@ pub struct Buffer {
 impl Buffer {
     #[cfg(not(no_global_oom_handling))]
     #[inline]
-    pub fn with_capacity(capacity: usize) -> Self {
+    pub(super) fn with_capacity(capacity: usize) -> Self {
         let buf = Box::new_uninit_slice(capacity);
         Self { buf, pos: 0, filled: 0, initialized: false }
     }
 
-    #[doc(hidden)]
-    #[unstable(feature = "core_io_internals", reason = "exposed only for libstd", issue = "none")]
     #[inline]
-    pub fn try_with_capacity(capacity: usize) -> io::Result<Self> {
+    pub(super) fn try_with_capacity(capacity: usize) -> io::Result<Self> {
         match Box::try_new_uninit_slice(capacity) {
             Ok(buf) => Ok(Self { buf, pos: 0, filled: 0, initialized: false }),
             Err(_) => {
@@ -52,49 +52,47 @@ impl Buffer {
     }
 
     #[inline]
-    pub fn buffer(&self) -> &[u8] {
+    pub(super) fn buffer(&self) -> &[u8] {
         // SAFETY: self.pos and self.filled are valid, and self.filled >= self.pos, and
         // that region is initialized because those are all invariants of this type.
         unsafe { self.buf.get_unchecked(self.pos..self.filled).assume_init_ref() }
     }
 
     #[inline]
-    pub fn capacity(&self) -> usize {
+    pub(super) fn capacity(&self) -> usize {
         self.buf.len()
     }
 
     #[inline]
-    pub fn filled(&self) -> usize {
+    pub(super) fn filled(&self) -> usize {
         self.filled
     }
 
     #[inline]
-    pub fn pos(&self) -> usize {
+    pub(super) fn pos(&self) -> usize {
         self.pos
     }
 
     // This is only used by a test which asserts that the initialization-tracking is correct.
-    #[doc(hidden)]
-    #[unstable(feature = "core_io_internals", reason = "exposed only for libstd", issue = "none")]
-    pub fn initialized(&self) -> bool {
+    pub(super) fn initialized(&self) -> bool {
         self.initialized
     }
 
     #[inline]
-    pub fn discard_buffer(&mut self) {
+    pub(super) fn discard_buffer(&mut self) {
         self.pos = 0;
         self.filled = 0;
     }
 
     #[inline]
-    pub fn consume(&mut self, amt: usize) {
+    pub(super) fn consume(&mut self, amt: usize) {
         self.pos = cmp::min(self.pos + amt, self.filled);
     }
 
     /// If there are `amt` bytes available in the buffer, pass a slice containing those bytes to
     /// `visitor` and return true. If there are not enough bytes available, return false.
     #[inline]
-    pub fn consume_with<V>(&mut self, amt: usize, mut visitor: V) -> bool
+    pub(super) fn consume_with<V>(&mut self, amt: usize, mut visitor: V) -> bool
     where
         V: FnMut(&[u8]),
     {
@@ -109,12 +107,12 @@ impl Buffer {
     }
 
     #[inline]
-    pub fn unconsume(&mut self, amt: usize) {
+    pub(super) fn unconsume(&mut self, amt: usize) {
         self.pos = self.pos.saturating_sub(amt);
     }
 
     /// Read more bytes into the buffer without discarding any of its contents
-    pub fn read_more(&mut self, mut reader: impl Read) -> io::Result<usize> {
+    pub(super) fn read_more(&mut self, mut reader: impl Read) -> io::Result<usize> {
         let mut buf = BorrowedBuf::from(&mut self.buf[self.filled..]);
 
         if self.initialized {
@@ -131,14 +129,14 @@ impl Buffer {
     }
 
     /// Remove bytes that have already been read from the buffer.
-    pub fn backshift(&mut self) {
+    pub(super) fn backshift(&mut self) {
         self.buf.copy_within(self.pos..self.filled, 0);
         self.filled -= self.pos;
         self.pos = 0;
     }
 
     #[inline]
-    pub fn fill_buf(&mut self, mut reader: impl Read) -> io::Result<&[u8]> {
+    pub(super) fn fill_buf(&mut self, mut reader: impl Read) -> io::Result<&[u8]> {
         // If we've reached the end of our internal buffer then we need to fetch
         // some more data from the reader.
         // Branch using `>=` instead of the more correct `==`