Fixed compile issue on rustc 1.60 UNTESTED

src/main.rs

@@ -1,4 +1,7 @@
-#![feature(slice_internals, read_initializer, new_uninit)]
+#![feature(slice_internals)]
+#![feature(read_buf)]
+#![feature(new_uninit)]
+#![feature(maybe_uninit_slice)]
 
 use unsafe_std::bufread::{UnsafeBufRead, UnsafeLines};
 use unsafe_std::bufreader::UnsafeBufReader;

src/unsafe_std/bufreader.rs

@@ -2,12 +2,15 @@
 
 use crate::unsafe_std::bufread::UnsafeBufRead;
 use std::io::Read;
+use std::io::ReadBuf;
+use std::mem::MaybeUninit;
 
 pub struct UnsafeBufReader<R> {
     inner: R,
-    buf: Box<[u8]>,
+    buf: Box<[MaybeUninit<u8>]>,
     pos: usize,
     cap: usize,
+    init: usize,
 }
 
 impl<R: Read> UnsafeBufReader<R> {
@@ -17,11 +20,14 @@ impl<R: Read> UnsafeBufReader<R> {
 
     pub fn with_capacity(capacity: usize, inner: R) -> UnsafeBufReader<R> {
         unsafe {
-            let mut buf = Box::new_uninit_slice(capacity).assume_init();
-            inner.initializer().initialize(&mut buf);
-            UnsafeBufReader { inner, buf, pos: 0, cap: 0 }
+            let buf = Box::new_uninit_slice(capacity);
+            UnsafeBufReader { inner, buf, pos: 0, cap: 0, init: 0 }
         }
     }
+
+    pub fn buffer(&self) -> &[u8] {
+        unsafe { MaybeUninit::slice_assume_init_ref(&self.buf[self.pos..self.cap]) }
+    }
 }
 
 impl<R> UnsafeBufReader<R> {
@@ -51,10 +57,20 @@ impl<R: Read> UnsafeBufRead for UnsafeBufReader<R> {
     fn fill_buf(&mut self) -> std::io::Result<&[u8]> {
         if self.pos >= self.cap {
             //debug_assert!(self.pos == self.cap); // Debug assertions? Only slow us down!
-            self.cap = self.inner.read(&mut self.buf)?;
+            let mut readbuf = ReadBuf::uninit(&mut self.buf);
+            unsafe {
+                readbuf.assume_init(self.init);
+            }
+
+            self.inner.read_buf(&mut readbuf)?;
+
+            self.cap = readbuf.filled_len();
+            self.init = readbuf.initialized_len();
+
             self.pos = 0;
         }
-        Ok(&self.buf[self.pos..self.cap])
+
+        Ok(self.buffer())
     }
 
     fn consume(&mut self, amt: usize) {