Change io crate & add a small shell

.cargo/config.toml

@@ -3,8 +3,6 @@ target = "riscv64.json"
 
 [unstable]
 json-target-spec = true
-build-std = ["core", "compiler_builtins", "alloc"]
-build-std-features = ["compiler-builtins-mem"]
 
 [target.riscv64]
 rustflags = [

.gdbinit

@@ -1,6 +1,6 @@
-file target/riscv64/debug/kernel-rust
+# file target/riscv64/debug/kernel-rust
 target remote localhost:1234
-break machine_mode_entry
-# break *0x800bf000
-# add-symbol-file target/riscv64/debug/test_pic 0x800bf000
+# break machine_mode_entry
+break *0x800cfdd8
+add-symbol-file target/riscv64/debug/agetty 0x800cfdd8
 c

.gitignore

@@ -7,3 +7,6 @@
 disk.img
 **/*.mem
 mnt
+
+sysroot/lib/rustlib/riscv64
+library/alloc

Cargo.toml

@@ -1,6 +1,7 @@
 [workspace]
 resolver = "3"
-members = ["crates/bytes-struct","crates/io","crates/std", "crates/shared", "user/*"]
+members = ["crates/ansii","user/*"]
+exclude = ["library", "build-tools", "crates/io"]
 
 [package]
 name = "kernel-rust"
@@ -12,10 +13,11 @@ bitflags = "2"
 embedded-alloc = "0.7"
 kernel-macros = { path = "crates/kernel-macros" }
 bytes-struct = { path = "crates/bytes-struct" }
+ansii = { path = "crates/ansii" }
 log = "0.4"
 critical-section = { version = "1", features = ["restore-state-bool"] }
 bffs = { path = "crates/bffs", features = ["alloc"] }
-io = { path = "crates/io", features = ["alloc"] }
+io = { package = "no-std-io", path = "crates/io" }
 shared = { path = "crates/shared", features = ["kernel"] }
 goblin = { version = "0.7", default-features = false, features = ["elf32", "elf64", "endian_fd"] }
 hashbrown = "0.16"

build-tools/.cargo/config.toml

@@ -0,0 +1,2 @@
+[build]
+target = "x86_64-unknown-linux-gnu"

build-tools/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "build-tools"
+version = "0.1.0"
+edition = "2024"
+
+[[bin]]
+name = "gen-symbols"
+path = "src/gen_symbols.rs"
+
+[dependencies]
+rayon = "1.11"
+object = "0.32"
+addr2line = "0.21"
+rustc-demangle = "0.1"

build-tools/src/gen_symbols.rs

@@ -0,0 +1,107 @@
+use addr2line::Context;
+use object::{Object, ObjectSymbol, SymbolKind};
+use std::collections::HashMap;
+use std::fs::File;
+use std::io::{BufWriter, Write};
+use std::path::Path;
+
+#[repr(C, packed(4))]
+#[derive(Debug)]
+struct RawSymbol {
+    addr: u64,
+    line: u32,
+    name_off: u32,
+    file_off: u32,
+}
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let elf_path = "../target/riscv64/debug/kernel-rust";
+    let bin_data = std::fs::read(elf_path)?;
+    let obj_file = object::File::parse(&*bin_data)?;
+
+    let context = Context::new(&obj_file)?;
+
+    let mut symbols_list = Vec::new();
+    let mut string_table = Vec::new();
+    let mut str_cache = HashMap::new();
+
+    // Helper pour gérer la table des chaînes (String Table)
+    let mut add_string = |s: &str| -> u32 {
+        *str_cache.entry(s.to_string()).or_insert_with(|| {
+            let off = string_table.len() as u32;
+            string_table.extend_from_slice(s.as_bytes());
+            string_table.push(0); // Null terminator
+            off
+        })
+    };
+
+    println!("Extraction des symboles depuis {}...", elf_path);
+
+    obj_file.symbols().enumerate().for_each(|(_i, sym)| {
+        // On ne garde que les fonctions (Text)
+        if sym.kind() == SymbolKind::Text && sym.size() > 0 {
+            let addr = sym.address();
+            let raw_name = sym.name().unwrap_or("unknown");
+            let name = format!("{:#}", rustc_demangle::demangle(raw_name));
+
+            let mut frames = context.find_frames(addr).skip_all_loads().unwrap();
+
+            let (file, line) = if let Ok(Some(frame)) = frames.next() {
+                let f = frame
+                    .location
+                    .as_ref()
+                    .and_then(|l| {
+                        l.file.and_then(|file| {
+                            Path::new(file)
+                                .strip_prefix(std::env::current_dir().unwrap().parent().unwrap())
+                                .map_or(Some(file), |p| p.to_str())
+                        })
+                    })
+                    .unwrap_or("unknown");
+                let l = frame.location.as_ref().and_then(|l| l.line).unwrap_or(0);
+                (f, l)
+            } else {
+                ("unknown", 0)
+            };
+
+            symbols_list.push(RawSymbol {
+                addr,
+                line,
+                name_off: add_string(&name),
+                file_off: add_string(file),
+            });
+        }
+    });
+
+    // Tri par adresse pour la recherche binaire au runtime
+    symbols_list.sort_by_key(|s| s.addr);
+
+    // Écriture du fichier symbols.bin
+    let mut f = BufWriter::new(File::create("../target/symbols.bin")?);
+
+    // Header : [u64: count] [u64: string_table_offset]
+    let header_size = 16;
+    let sym_table_size = symbols_list.len() * std::mem::size_of::<RawSymbol>();
+    f.write_all(&(symbols_list.len() as u64).to_le_bytes())?;
+    f.write_all(&((header_size + sym_table_size) as u64).to_le_bytes())?;
+
+    // Table des symboles
+    for sym in &symbols_list {
+        unsafe {
+            let bytes = std::slice::from_raw_parts(
+                (sym as *const RawSymbol) as *const u8,
+                std::mem::size_of::<RawSymbol>(),
+            );
+            f.write_all(bytes)?;
+        }
+    }
+
+    // Table des noms
+    f.write_all(&string_table)?;
+
+    println!(
+        "Terminé ! {} symboles écrits dans symbols.bin",
+        symbols_list.len()
+    );
+    Ok(())
+}

crates/ansii/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "ansii"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+winnow = { version = "1", default-features = false, features = ["binary", "ascii"] }

crates/ansii/src/lib.rs

@@ -0,0 +1,66 @@
+#![no_std]
+
+use winnow::Result;
+use winnow::ascii::dec_uint;
+use winnow::combinator::{alt, preceded, seq};
+use winnow::error::ContextError;
+use winnow::prelude::*;
+
+pub enum AnsiiEscape {
+    Color16(ColorPlace, Color16Type, u8),
+    Color256(u8),
+    ColorRGB(ColorPlace, u8, u8, u8),
+}
+pub enum ColorPlace {
+    Foreground,
+    Background,
+}
+pub enum Color16Type {
+    Normal,
+    Bold,
+    Brigth,
+}
+
+fn parse_color16(input: &mut &str) -> Result<AnsiiEscape> {
+    let (c, _) = preceded("[", seq!(dec_uint, "m")).parse_next(input)?;
+    if c < 30 || c == 38 || c == 48 || c > 49 {
+        Err(ContextError::new())
+    } else {
+        Ok(AnsiiEscape::Color16(
+            ColorPlace::Foreground,
+            Color16Type::Normal,
+            c,
+        ))
+    }
+}
+
+fn parse_color_rgb(input: &mut &str) -> Result<AnsiiEscape> {
+    let (t, _, r, _, g, _, b, _) = preceded(
+        "[",
+        seq!(
+            alt(("38", "48")),
+            ";",
+            dec_uint,
+            ";",
+            dec_uint,
+            ";",
+            dec_uint,
+            "m"
+        ),
+    )
+    .parse_next(input)?;
+    Ok(AnsiiEscape::ColorRGB(
+        if t == "38" {
+            ColorPlace::Foreground
+        } else {
+            ColorPlace::Background
+        },
+        r,
+        g,
+        b,
+    ))
+}
+
+pub fn parse_ansii(input: &mut &str) -> Result<AnsiiEscape> {
+    alt((parse_color_rgb, parse_color16)).parse_next(input)
+}

crates/bffs/Cargo.toml

@@ -4,7 +4,7 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
-io = { path = "../io" }
+io = { package = "no-std-io", path = "../io" }
 bitflags = "2"
 
 [features]

crates/bffs/src/boot_sector.rs

@@ -1,5 +1,6 @@
-use crate::error::Error;
-use io::{Read, ReadLeExt};
+use io::Read;
+
+use crate::io_ext::ReadLeExt;
 
 #[derive(Debug, Clone, Copy)]
 pub struct Fat32BootSector {
@@ -94,7 +95,7 @@ impl Fat32BootSector {
 }
 
 impl Fat32BootSector {
-    pub fn deserialize<T: Read>(disk: &mut T) -> Result<Self, Error<T::Error>> {
+    pub fn deserialize<T: Read>(disk: &mut T) -> Result<Self, io::Error> {
         let mut jump_boot = [0u8; _];
         disk.read_exact(&mut jump_boot)?;
         let mut oem_name = [0u8; _];

crates/bffs/src/dir.rs

@@ -1,36 +1,32 @@
 use crate::{
     Fat32FileSystem, ReadSeek, ReadWriteSeek,
     entry::{DirEntry, DirectoryIterator},
-    error::Error,
     file::{File, RawFile},
     path::Path,
 };
-use io::{self, IoBase, Read, Seek, Write};
+use io::{self, Read, Seek, Write};
 
 pub struct Dir<'a, T> {
     raw: RawFile<'a, T>,
     fs: &'a Fat32FileSystem<T>,
 }
 
-impl<'a, T: IoBase> IoBase for Dir<'a, T> {
-    type Error = Error<T::Error>;
-}
 impl<'a, T: ReadSeek> Seek for Dir<'a, T> {
-    fn seek(&mut self, pos: io::SeekFrom) -> Result<u64, Self::Error> {
+    fn seek(&mut self, pos: io::SeekFrom) -> io::Result<u64> {
         self.raw.seek(pos)
     }
 }
 impl<'a, T: ReadSeek> Read for Dir<'a, T> {
-    fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         self.raw.read(buf)
     }
 }
 impl<'a, T: ReadWriteSeek> Write for Dir<'a, T> {
-    fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
         self.raw.write(buf)
     }
 
-    fn flush(&mut self) -> Result<(), Self::Error> {
+    fn flush(&mut self) -> io::Result<()> {
         self.raw.flush()
     }
 }
@@ -44,7 +40,7 @@ impl<'a, T> Dir<'a, T> {
     }
 }
 impl<'a, T: ReadSeek> Dir<'a, T> {
-    pub fn open_entry<P: AsRef<Path>>(&self, path: P) -> Result<DirEntry<'a, T>, Error<T::Error>> {
+    pub fn open_entry<P: AsRef<Path>>(&self, path: P) -> Result<DirEntry<'a, T>, io::Error> {
         if path.as_ref().is_absolute() {
             return self.fs.open_entry(path);
         }
@@ -56,16 +52,16 @@ impl<'a, T: ReadSeek> Dir<'a, T> {
                     if f.is_dir() {
                         return f.to_dir().open_entry(entry_name);
                     } else {
-                        return Err(Error::NotFound);
+                        return Err(io::Error::from(io::ErrorKind::NotFound));
                     }
                 } else {
                     return Ok(f);
                 }
             }
         }
-        Err(Error::NotFound)
+        Err(io::Error::from(io::ErrorKind::NotFound))
     }
-    pub fn open_file<P: AsRef<Path>>(&self, path: P) -> Result<File<'a, T>, Error<T::Error>> {
+    pub fn open_file<P: AsRef<Path>>(&self, path: P) -> Result<File<'a, T>, io::Error> {
         if path.as_ref().is_absolute() {
             return self.fs.open_file(path);
         }
@@ -74,19 +70,19 @@ impl<'a, T: ReadSeek> Dir<'a, T> {
         match dirname {
             Some(name) => {
                 if !entry.is_dir() {
-                    return Err(Error::NotFound);
+                    return Err(io::Error::from(io::ErrorKind::NotFound));
                 }
                 entry.to_dir().open_file(name)
             }
             None => {
                 if !entry.is_file() {
-                    return Err(Error::NotFound);
+                    return Err(io::Error::from(io::ErrorKind::NotFound));
                 }
                 Ok(entry.to_file())
             }
         }
     }
-    pub fn open_dir<P: AsRef<Path>>(&self, path: P) -> Result<Self, Error<T::Error>> {
+    pub fn open_dir<P: AsRef<Path>>(&self, path: P) -> Result<Self, io::Error> {
         let path = path.as_ref();
         if path.is_absolute() {
             return self.fs.open_dir(path);
@@ -94,7 +90,7 @@ impl<'a, T: ReadSeek> Dir<'a, T> {
         let (start, dirname) = path.split_path();
         let entry = self.open_entry(start)?;
         if !entry.is_dir() {
-            return Err(Error::NotFound);
+            return Err(io::Error::from(io::ErrorKind::NotFound));
         }
         match dirname {
             Some(name) => entry.to_dir().open_dir(name),

crates/bffs/src/entry.rs

@@ -1,15 +1,15 @@
 use core::{array::IntoIter, iter::Copied, str::Utf8Error};
 use core::{char::DecodeUtf16, marker::PhantomData, slice::Iter};
 
+use crate::io_ext::ReadLeExt;
 use crate::{
     Fat32FileSystem, ReadSeek,
     consts::FATAttr,
     dir::Dir,
-    error::Error,
     file::{File, RawFile},
 };
 
-use io::{IoBase, Read, ReadLeExt};
+use io::Read;
 
 #[cfg(feature = "alloc")]
 use alloc::borrow::ToOwned;
@@ -33,7 +33,7 @@ pub struct FatDirEntry {
 }
 
 impl FatDirEntry {
-    pub fn deserialize<T: Read>(reader: &mut T) -> Result<Self, T::Error> {
+    pub fn deserialize<T: Read>(reader: &mut T) -> Result<Self, io::Error> {
         let mut name = [0u8; _];
         reader.read_exact(&mut name)?;
         let attr = reader.read_u8()?;
@@ -131,7 +131,7 @@ pub struct LongFileNameBuilder<T> {
     _phantom: PhantomData<T>,
 }
 
-impl<T: IoBase> LongFileNameBuilder<T> {
+impl<T> LongFileNameBuilder<T> {
     pub fn new() -> Self {
         Self {
             inner: [0; _],
@@ -160,12 +160,12 @@ impl<T: IoBase> LongFileNameBuilder<T> {
         }
     }
     #[cfg(feature = "alloc")]
-    pub fn to_string(&self) -> Result<String, Error<T::Error>> {
+    pub fn to_string(&self) -> Result<String, io::Error> {
         self.iter().try_collect::<String>()
     }
 }
 
-impl<T: IoBase> IntoIterator for LongFileNameBuilder<T> {
+impl<T> IntoIterator for LongFileNameBuilder<T> {
     type Item = <LongFileNameIterator<T, IntoIter<u16, 256>> as Iterator>::Item;
 
     type IntoIter = LongFileNameIterator<T, IntoIter<u16, 256>>;
@@ -178,7 +178,7 @@ impl<T: IoBase> IntoIterator for LongFileNameBuilder<T> {
     }
 }
 
-impl<T: IoBase> LongFileNameBuilder<T> {
+impl<T> LongFileNameBuilder<T> {
     pub fn iter(&self) -> LongFileNameIterator<T, Copied<Iter<'_, u16>>> {
         LongFileNameIterator {
             iterator: char::decode_utf16(self.inner.iter().copied()),
@@ -192,8 +192,8 @@ pub struct LongFileNameIterator<T, I: Iterator<Item = u16>> {
     _phantom: PhantomData<T>,
 }
 
-impl<T: IoBase, I: Iterator<Item = u16>> Iterator for LongFileNameIterator<T, I> {
-    type Item = Result<char, Error<T::Error>>;
+impl<T, I: Iterator<Item = u16>> Iterator for LongFileNameIterator<T, I> {
+    type Item = Result<char, io::Error>;
 
     fn next(&mut self) -> Option<Self::Item> {
         match self.iterator.next()? {
@@ -204,12 +204,15 @@ impl<T: IoBase, I: Iterator<Item = u16>> Iterator for LongFileNameIterator<T, I>
                     Some(Ok(value))
                 }
             }
-            Err(_) => Some(Err(Error::UnsupportedFileNameCharacter)),
+            Err(_) => Some(Err(io::Error::new(
+                io::ErrorKind::Unsupported,
+                "Unsupported file name character",
+            ))),
         }
     }
 }
 
-impl<T: IoBase> Default for LongFileNameBuilder<T> {
+impl<T> Default for LongFileNameBuilder<T> {
     fn default() -> Self {
         Self::new()
     }
@@ -226,7 +229,7 @@ impl<'a, T> DirectoryIterator<'a, T> {
 }
 
 impl<'a, T: ReadSeek + 'a> Iterator for DirectoryIterator<'a, T> {
-    type Item = Result<DirEntry<'a, T>, Error<T::Error>>;
+    type Item = Result<DirEntry<'a, T>, io::Error>;
 
     fn next(&mut self) -> Option<Self::Item> {
         let mut lfn_builder = LongFileNameBuilder::new();
@@ -283,7 +286,7 @@ pub struct DirEntry<'a, T> {
     fs: &'a Fat32FileSystem<T>,
 }
 
-impl<'a, T: IoBase> DirEntry<'a, T> {
+impl<'a, T> DirEntry<'a, T> {
     fn new(
         entry: FatDirEntry,
         short_name: [u8; 11],
@@ -298,13 +301,16 @@ impl<'a, T: IoBase> DirEntry<'a, T> {
         }
     }
     #[cfg(feature = "alloc")]
-    pub fn name(&self) -> Result<String, Error<T::Error>> {
+    pub fn name(&self) -> Result<String, io::Error> {
         if let Some(long_name) = self.long_name() {
             long_name.to_string()
         } else {
-            self.short_name()
-                .map(|n| n.to_owned())
-                .map_err(|_| Error::UnsupportedFileNameCharacter)
+            self.short_name().map(|n| n.to_owned()).map_err(|_| {
+                io::Error::new(
+                    io::ErrorKind::Unsupported,
+                    "Unsupported file name character",
+                )
+            })
         }
     }
     pub fn long_name(&self) -> Option<&LongFileNameBuilder<T>> {

crates/bffs/src/error.rs

@@ -1,79 +1 @@
-use io::error::IoError;
 
-/// Error enum with all errors that can be returned by functions from this crate
-///
-/// Generic parameter `T` is a type of external error returned by the user provided storage
-#[derive(Debug)]
-#[non_exhaustive]
-pub enum Error<T> {
-    /// A user provided storage instance returned an error during an input/output operation.
-    Io(T),
-    /// A read operation cannot be completed because an end of a file has been reached prematurely.
-    UnexpectedEof,
-    /// A write operation cannot be completed because `Write::write` returned 0.
-    WriteZero,
-    /// A parameter was incorrect.
-    InvalidInput,
-    /// A requested file or directory has not been found.
-    NotFound,
-    /// A file or a directory with the same name already exists.
-    AlreadyExists,
-    /// An operation cannot be finished because a directory is not empty.
-    DirectoryIsNotEmpty,
-    /// File system internal structures are corrupted/invalid.
-    CorruptedFileSystem,
-    /// There is not enough free space on the storage to finish the requested operation.
-    NotEnoughSpace,
-    /// The provided file name is either too long or empty.
-    InvalidFileNameLength,
-    /// The provided file name contains an invalid character.
-    UnsupportedFileNameCharacter,
-    /// The file content contains invalid UTF-8 characters.
-    InvalidUTF8,
-}
-
-impl<T: IoError> From<T> for Error<T> {
-    fn from(error: T) -> Self {
-        Error::Io(error)
-    }
-}
-
-impl<T: core::fmt::Display> core::fmt::Display for Error<T> {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        match self {
-            Error::Io(io_error) => write!(f, "IO error: {}", io_error),
-            Error::UnexpectedEof => write!(f, "Unexpected end of file"),
-            Error::NotEnoughSpace => write!(f, "Not enough space"),
-            Error::WriteZero => write!(f, "Write zero"),
-            Error::InvalidInput => write!(f, "Invalid input"),
-            Error::InvalidFileNameLength => write!(f, "Invalid file name length"),
-            Error::UnsupportedFileNameCharacter => write!(f, "Unsupported file name character"),
-            Error::DirectoryIsNotEmpty => write!(f, "Directory is not empty"),
-            Error::NotFound => write!(f, "No such file or directory"),
-            Error::AlreadyExists => write!(f, "File or directory already exists"),
-            Error::CorruptedFileSystem => write!(f, "Corrupted file system"),
-            Error::InvalidUTF8 => write!(f, "File contains invalid UTF-8 characters"),
-        }
-    }
-}
-
-impl<T: core::fmt::Debug + IoError> IoError for Error<T> {
-    fn is_interrupted(&self) -> bool {
-        match self {
-            Error::<T>::Io(io_error) => io_error.is_interrupted(),
-            _ => false,
-        }
-    }
-
-    fn new_unexpected_eof_error() -> Self {
-        Error::<T>::UnexpectedEof
-    }
-
-    fn new_write_zero_error() -> Self {
-        Error::<T>::WriteZero
-    }
-
-    fn new_invalid_utf8_error() -> Self {
-        Error::<T>::InvalidUTF8
-    }
-}

crates/bffs/src/file.rs

@@ -1,10 +1,9 @@
 use crate::{
     Fat32FileSystem, ReadSeek, ReadWriteSeek,
     consts::{FAT32_BAD_CLUSTER, FAT32_END_OF_CHAIN},
-    error::Error,
 };
 
-use io::{self, IoBase, Read, Seek, Write};
+use io::{self, Read, Seek, Write};
 
 #[derive(Debug, Clone)]
 pub struct RawFile<'a, T> {
@@ -30,12 +29,8 @@ impl<'a, T> RawFile<'a, T> {
     }
 }
 
-impl<'a, T: IoBase> IoBase for RawFile<'a, T> {
-    type Error = Error<T::Error>;
-}
-
 impl<'a, T: ReadSeek> Seek for RawFile<'a, T> {
-    fn seek(&mut self, pos: io::SeekFrom) -> Result<u64, Self::Error> {
+    fn seek(&mut self, pos: io::SeekFrom) -> Result<u64, io::Error> {
         let new_pos = match pos {
             io::SeekFrom::Start(s) => s,
             io::SeekFrom::Current(c) => (self.pos as i64 + c) as u64,
@@ -67,7 +62,7 @@ impl<'a, T: ReadSeek> Seek for RawFile<'a, T> {
 }
 
 impl<'a, T: ReadSeek> Read for RawFile<'a, T> {
-    fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
+    fn read(&mut self, buf: &mut [u8]) -> Result<usize, io::Error> {
         let max_len = self
             .size
             .map(|size| core::cmp::min(buf.len(), size as usize - self.pos as usize))
@@ -116,11 +111,11 @@ impl<'a, T: ReadSeek> Read for RawFile<'a, T> {
     }
 }
 impl<'a, T: ReadWriteSeek> Write for RawFile<'a, T> {
-    fn write(&mut self, _buf: &[u8]) -> Result<usize, Self::Error> {
+    fn write(&mut self, _buf: &[u8]) -> Result<usize, io::Error> {
         todo!()
     }
 
-    fn flush(&mut self) -> Result<(), Self::Error> {
+    fn flush(&mut self) -> Result<(), io::Error> {
         todo!()
     }
 }
@@ -132,25 +127,22 @@ pub struct File<'a, T> {
     fs: &'a Fat32FileSystem<T>,
 }
 
-impl<'a, T: IoBase> IoBase for File<'a, T> {
-    type Error = Error<T::Error>;
-}
 impl<'a, T: ReadSeek> Seek for File<'a, T> {
-    fn seek(&mut self, pos: io::SeekFrom) -> Result<u64, Self::Error> {
+    fn seek(&mut self, pos: io::SeekFrom) -> Result<u64, io::Error> {
         self.raw.seek(pos)
     }
 }
 impl<'a, T: ReadSeek> Read for File<'a, T> {
-    fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
+    fn read(&mut self, buf: &mut [u8]) -> Result<usize, io::Error> {
         self.raw.read(buf)
     }
 }
 impl<'a, T: ReadWriteSeek> Write for File<'a, T> {
-    fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
+    fn write(&mut self, buf: &[u8]) -> Result<usize, io::Error> {
         self.raw.write(buf)
     }
 
-    fn flush(&mut self) -> Result<(), Self::Error> {
+    fn flush(&mut self) -> Result<(), io::Error> {
         self.raw.flush()
     }
 }

crates/bffs/src/io_ext.rs

@@ -0,0 +1,27 @@
+use io::{Read, Result};
+
+pub trait ReadLeExt {
+    fn read_u8(&mut self) -> Result<u8>;
+    fn read_u16_le(&mut self) -> Result<u16>;
+    fn read_u32_le(&mut self) -> Result<u32>;
+}
+
+impl<T: Read> ReadLeExt for T {
+    fn read_u8(&mut self) -> Result<u8> {
+        let mut buf = [0_u8; 1];
+        self.read_exact(&mut buf)?;
+        Ok(buf[0])
+    }
+
+    fn read_u16_le(&mut self) -> Result<u16> {
+        let mut buf = [0_u8; 2];
+        self.read_exact(&mut buf)?;
+        Ok(u16::from_le_bytes(buf))
+    }
+
+    fn read_u32_le(&mut self) -> Result<u32> {
+        let mut buf = [0_u8; 4];
+        self.read_exact(&mut buf)?;
+        Ok(u32::from_le_bytes(buf))
+    }
+}

crates/bffs/src/lib.rs

@@ -1,20 +1,15 @@
 #![feature(iterator_try_collect, iter_order_by)]
+#![allow(unused_features)]
 #![cfg_attr(any(not(feature = "std"), target_arch = "riscv64"), no_std)]
 
 use core::cell::RefCell;
 use core::fmt::Display;
 
 use crate::{
-    boot_sector::Fat32BootSector,
-    consts::FAT32_CLUSTER_MASK,
-    dir::Dir,
-    entry::{DirEntry, FatEntry},
-    error::Error,
-    file::{File, RawFile},
-    path::Path,
+    boot_sector::Fat32BootSector, consts::FAT32_CLUSTER_MASK, dir::Dir, entry::{DirEntry, FatEntry}, file::{File, RawFile}, io_ext::ReadLeExt, path::Path
 };
 
-use io::{Read, ReadLeExt, Seek, Write};
+use io::{Read, Seek, Write};
 
 #[cfg(feature = "alloc")]
 extern crate alloc;
@@ -23,8 +18,8 @@ pub mod boot_sector;
 pub mod consts;
 pub mod dir;
 pub mod entry;
-pub mod error;
 pub mod file;
+pub mod io_ext;
 pub mod path;
 
 pub trait ReadSeek: Read + Seek {}
@@ -46,7 +41,7 @@ pub struct Fat32FsInfo {
 }
 
 impl Fat32FsInfo {
-    pub fn deserialize<T: Read>(disk: &mut T) -> Result<Self, Error<T::Error>> {
+    pub fn deserialize<T: Read>(disk: &mut T) -> Result<Self, io::Error> {
         let lead_signature = disk.read_u32_le()?;
         let mut reserved1 = [0u8; _];
         disk.read_exact(&mut reserved1)?;
@@ -81,7 +76,7 @@ impl<T> Display for Fat32FileSystem<T> {
 }
 
 impl<T: ReadSeek> Fat32FileSystem<T> {
-    pub fn new(mut device: T) -> Result<Self, Error<T::Error>> {
+    pub fn new(mut device: T) -> Result<Self, io::Error> {
         device.seek(io::SeekFrom::Start(0))?;
 
         let boot_sector = Fat32BootSector::deserialize(&mut device)?;
@@ -91,7 +86,7 @@ impl<T: ReadSeek> Fat32FileSystem<T> {
         })
     }
     /// Get the next cluster from the current one
-    fn get_next_cluster(&self, current_cluster: u32) -> Result<u32, Error<T::Error>> {
+    fn get_next_cluster(&self, current_cluster: u32) -> Result<u32, io::Error> {
         let fat_offset =
             self.fat_start_offset() + (current_cluster as u64 * size_of::<FatEntry>() as u64);
         self.device
@@ -136,15 +131,15 @@ impl<T> Fat32FileSystem<T> {
     }
 }
 impl<T: ReadSeek> Fat32FileSystem<T> {
-    pub fn open_entry<P: AsRef<Path>>(&self, path: P) -> Result<DirEntry<'_, T>, Error<T::Error>> {
+    pub fn open_entry<P: AsRef<Path>>(&self, path: P) -> Result<DirEntry<'_, T>, io::Error> {
         let path = path.as_ref().as_str().trim_start_matches("/");
         self.root_directory().open_entry(path)
     }
-    pub fn open_dir<P: AsRef<Path>>(&self, path: P) -> Result<Dir<'_, T>, Error<T::Error>> {
+    pub fn open_dir<P: AsRef<Path>>(&self, path: P) -> Result<Dir<'_, T>, io::Error> {
         let path = path.as_ref().as_str().trim_start_matches("/");
         self.root_directory().open_dir(path)
     }
-    pub fn open_file<P: AsRef<Path>>(&self, path: P) -> Result<File<'_, T>, Error<T::Error>> {
+    pub fn open_file<P: AsRef<Path>>(&self, path: P) -> Result<File<'_, T>, io::Error> {
         let path = path.as_ref().as_str().trim_start_matches("/");
         self.root_directory().open_file(path)
     }

crates/bffs/src/main.rs

@@ -9,7 +9,7 @@ pub fn main() {
 
     // walk(fs.root_directory());
 
-    let mut f = fs.open_file("/usr/bin/test_pic").unwrap();
+    let mut f = fs.open_file("/usr/bin/agetty").unwrap();
     let mut content = Vec::new();
     f.read_to_end(&mut content).unwrap();
     println!("file content len: {}", content.len());

crates/bffs/src/path.rs

@@ -1,3 +1,4 @@
+use core::fmt::Display;
 #[cfg(feature = "alloc")]
 use core::{borrow::Borrow, ops::Deref};
 
@@ -12,6 +13,12 @@ pub struct Path {
     inner: str,
 }
 
+impl Display for Path {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "{}", &self.inner)
+    }
+}
+
 impl From<&str> for &Path {
     fn from(value: &str) -> Self {
         unsafe { &*(value as *const str as *const Path) }

crates/io/.gitignore

@@ -0,0 +1,3 @@
+.cargo
+
+target

crates/io/Cargo.toml

@@ -1,10 +1,9 @@
 [package]
-name = "io"
+name = "no-std-io"
 version = "0.1.0"
 edition = "2024"
 
 [dependencies]
 
 [features]
-alloc = []
-std = ["alloc"]
+std = []

crates/io/justfile

@@ -0,0 +1,49 @@
+RUST_SRC := `rustc --print sysroot` / "lib/rustlib/src/rust/library/std/src"
+
+copy-io:
+    #!/usr/bin/env bash
+    set -e
+
+    FILES=(
+        "io/error/repr_unpacked.rs"
+        "io/error/repr_bitpacked.rs"
+        "io/error.rs"
+        "io/buffered/mod.rs"
+        "io/buffered/linewriter.rs"
+        "io/buffered/linewritershim.rs"
+        "io/buffered/bufwriter.rs"
+        "io/buffered/bufreader.rs"
+        "io/buffered/bufreader/buffer.rs"
+        "io/copy.rs"
+        "io/cursor.rs"
+        "io/impls.rs"
+        "io/prelude.rs"
+        "io/util.rs"
+        "io/mod.rs"
+    )
+
+    for f in "${FILES[@]}"; do
+        echo "Processing $f..."
+        DEST="src/$f"
+
+        mkdir -p "$(dirname "$DEST")"
+
+        cp "{{ RUST_SRC }}/$f" "$DEST"
+        sed -i -E -n '$!N; /^#\[cfg\(test\)\]\nmod tests/d; P; D' "$DEST"
+
+        if [[ "$f" == "io/error.rs" ]]; then
+            sed -i "s/alloc::/alloc_crate::/g" "$DEST"
+        fi
+
+        if [[ "$f" == "io/mod.rs" ]]; then
+            sed -i "/mod pipe/d" "$DEST"
+            sed -i "/self::pipe/d" "$DEST"
+            sed -i "/mod stdio/d" "$DEST"
+            sed -i "/stdio::/d" "$DEST"
+            sed -i "/self::stdio/d" "$DEST"
+            sed -i "/feature = \"is_terminal\"/d" "$DEST"
+            sed -i "/feature = \"print_internals\"/d" "$DEST"
+            sed -i "/feature = \"internal_output_capture\"/d" "$DEST"
+            sed -i "/feature = \"anonymous_pipe\"/d" "$DEST"
+        fi
+    done

crates/io/src/error.rs

@@ -1,48 +0,0 @@
-/// Trait that should be implemented by errors returned from the user supplied storage.
-///
-/// Implementations for `std::io::Error` and `()` are provided by this crate.
-pub trait IoError: core::fmt::Debug {
-    fn is_interrupted(&self) -> bool;
-    fn new_unexpected_eof_error() -> Self;
-    fn new_write_zero_error() -> Self;
-    fn new_invalid_utf8_error() -> Self;
-}
-
-impl IoError for () {
-    fn is_interrupted(&self) -> bool {
-        false
-    }
-
-    fn new_unexpected_eof_error() -> Self {
-        // empty
-    }
-
-    fn new_write_zero_error() -> Self {
-        // empty
-    }
-
-    fn new_invalid_utf8_error() -> Self {
-        // empty
-    }
-}
-
-#[cfg(all(feature = "std", not(target_arch = "riscv64")))]
-impl IoError for std::io::Error {
-    fn is_interrupted(&self) -> bool {
-        self.kind() == std::io::ErrorKind::Interrupted
-    }
-
-    fn new_unexpected_eof_error() -> Self {
-        Self::new(
-            std::io::ErrorKind::UnexpectedEof,
-            "failed to fill whole buffer",
-        )
-    }
-
-    fn new_write_zero_error() -> Self {
-        Self::new(
-            std::io::ErrorKind::WriteZero,
-            "failed to write whole buffer",
-        )
-    }
-}

crates/io/src/io/buffered/bufreader.rs

@@ -0,0 +1,592 @@
+mod buffer;
+
+use buffer::Buffer;
+
+use crate::fmt;
+use crate::io::{
+    self, BorrowedCursor, BufRead, DEFAULT_BUF_SIZE, IoSliceMut, Read, Seek, SeekFrom, SizeHint,
+    SpecReadByte, uninlined_slow_read_byte,
+};
+
+/// The `BufReader<R>` struct adds buffering to any reader.
+///
+/// It can be excessively inefficient to work directly with a [`Read`] instance.
+/// For example, every call to [`read`][`TcpStream::read`] on [`TcpStream`]
+/// results in a system call. A `BufReader<R>` performs large, infrequent reads on
+/// the underlying [`Read`] and maintains an in-memory buffer of the results.
+///
+/// `BufReader<R>` can improve the speed of programs that make *small* and
+/// *repeated* read calls to the same file or network socket. It does not
+/// help when reading very large amounts at once, or reading just one or a few
+/// times. It also provides no advantage when reading from a source that is
+/// already in memory, like a <code>[Vec]\<u8></code>.
+///
+/// When the `BufReader<R>` is dropped, the contents of its buffer will be
+/// discarded. Creating multiple instances of a `BufReader<R>` on the same
+/// stream can cause data loss. Reading from the underlying reader after
+/// unwrapping the `BufReader<R>` with [`BufReader::into_inner`] can also cause
+/// data loss.
+///
+/// [`TcpStream::read`]: crate::net::TcpStream::read
+/// [`TcpStream`]: crate::net::TcpStream
+///
+/// # Examples
+///
+/// ```no_run
+/// use std::io::prelude::*;
+/// use std::io::BufReader;
+/// use std::fs::File;
+///
+/// fn main() -> std::io::Result<()> {
+///     let f = File::open("log.txt")?;
+///     let mut reader = BufReader::new(f);
+///
+///     let mut line = String::new();
+///     let len = reader.read_line(&mut line)?;
+///     println!("First line is {len} bytes long");
+///     Ok(())
+/// }
+/// ```
+#[stable(feature = "rust1", since = "1.0.0")]
+pub struct BufReader<R: ?Sized> {
+    buf: Buffer,
+    inner: R,
+}
+
+impl<R: Read> BufReader<R> {
+    /// Creates a new `BufReader<R>` with a default buffer capacity. The default is currently 8 KiB,
+    /// but may change in the future.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use std::io::BufReader;
+    /// use std::fs::File;
+    ///
+    /// fn main() -> std::io::Result<()> {
+    ///     let f = File::open("log.txt")?;
+    ///     let reader = BufReader::new(f);
+    ///     Ok(())
+    /// }
+    /// ```
+    #[stable(feature = "rust1", since = "1.0.0")]
+    pub fn new(inner: R) -> BufReader<R> {
+        BufReader::with_capacity(DEFAULT_BUF_SIZE, inner)
+    }
+
+    pub(crate) fn try_new_buffer() -> io::Result<Buffer> {
+        Buffer::try_with_capacity(DEFAULT_BUF_SIZE)
+    }
+
+    pub(crate) fn with_buffer(inner: R, buf: Buffer) -> Self {
+        Self { inner, buf }
+    }
+
+    /// Creates a new `BufReader<R>` with the specified buffer capacity.
+    ///
+    /// # Examples
+    ///
+    /// Creating a buffer with ten bytes of capacity:
+    ///
+    /// ```no_run
+    /// use std::io::BufReader;
+    /// use std::fs::File;
+    ///
+    /// fn main() -> std::io::Result<()> {
+    ///     let f = File::open("log.txt")?;
+    ///     let reader = BufReader::with_capacity(10, f);
+    ///     Ok(())
+    /// }
+    /// ```
+    #[stable(feature = "rust1", since = "1.0.0")]
+    pub fn with_capacity(capacity: usize, inner: R) -> BufReader<R> {
+        BufReader { inner, buf: Buffer::with_capacity(capacity) }
+    }
+}
+
+impl<R: Read + ?Sized> BufReader<R> {
+    /// Attempt to look ahead `n` bytes.
+    ///
+    /// `n` must be less than or equal to `capacity`.
+    ///
+    /// The returned slice may be less than `n` bytes long if
+    /// end of file is reached.
+    ///
+    /// After calling this method, you may call [`consume`](BufRead::consume)
+    /// with a value less than or equal to `n` to advance over some or all of
+    /// the returned bytes.
+    ///
+    /// ## Examples
+    ///
+    /// ```rust
+    /// #![feature(bufreader_peek)]
+    /// use std::io::{Read, BufReader};
+    ///
+    /// let mut bytes = &b"oh, hello there"[..];
+    /// let mut rdr = BufReader::with_capacity(6, &mut bytes);
+    /// assert_eq!(rdr.peek(2).unwrap(), b"oh");
+    /// let mut buf = [0; 4];
+    /// rdr.read(&mut buf[..]).unwrap();
+    /// assert_eq!(&buf, b"oh, ");
+    /// assert_eq!(rdr.peek(5).unwrap(), b"hello");
+    /// let mut s = String::new();
+    /// rdr.read_to_string(&mut s).unwrap();
+    /// assert_eq!(&s, "hello there");
+    /// assert_eq!(rdr.peek(1).unwrap().len(), 0);
+    /// ```
+    #[unstable(feature = "bufreader_peek", issue = "128405")]
+    pub fn peek(&mut self, n: usize) -> io::Result<&[u8]> {
+        assert!(n <= self.capacity());
+        while n > self.buf.buffer().len() {
+            if self.buf.pos() > 0 {
+                self.buf.backshift();
+            }
+            let new = self.buf.read_more(&mut self.inner)?;
+            if new == 0 {
+                // end of file, no more bytes to read
+                return Ok(&self.buf.buffer()[..]);
+            }
+            debug_assert_eq!(self.buf.pos(), 0);
+        }
+        Ok(&self.buf.buffer()[..n])
+    }
+}
+
+impl<R: ?Sized> BufReader<R> {
+    /// Gets a reference to the underlying reader.
+    ///
+    /// It is inadvisable to directly read from the underlying reader.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use std::io::BufReader;
+    /// use std::fs::File;
+    ///
+    /// fn main() -> std::io::Result<()> {
+    ///     let f1 = File::open("log.txt")?;
+    ///     let reader = BufReader::new(f1);
+    ///
+    ///     let f2 = reader.get_ref();
+    ///     Ok(())
+    /// }
+    /// ```
+    #[stable(feature = "rust1", since = "1.0.0")]
+    pub fn get_ref(&self) -> &R {
+        &self.inner
+    }
+
+    /// Gets a mutable reference to the underlying reader.
+    ///
+    /// It is inadvisable to directly read from the underlying reader.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use std::io::BufReader;
+    /// use std::fs::File;
+    ///
+    /// fn main() -> std::io::Result<()> {
+    ///     let f1 = File::open("log.txt")?;
+    ///     let mut reader = BufReader::new(f1);
+    ///
+    ///     let f2 = reader.get_mut();
+    ///     Ok(())
+    /// }
+    /// ```
+    #[stable(feature = "rust1", since = "1.0.0")]
+    pub fn get_mut(&mut self) -> &mut R {
+        &mut self.inner
+    }
+
+    /// Returns a reference to the internally buffered data.
+    ///
+    /// Unlike [`fill_buf`], this will not attempt to fill the buffer if it is empty.
+    ///
+    /// [`fill_buf`]: BufRead::fill_buf
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use std::io::{BufReader, BufRead};
+    /// use std::fs::File;
+    ///
+    /// fn main() -> std::io::Result<()> {
+    ///     let f = File::open("log.txt")?;
+    ///     let mut reader = BufReader::new(f);
+    ///     assert!(reader.buffer().is_empty());
+    ///
+    ///     if reader.fill_buf()?.len() > 0 {
+    ///         assert!(!reader.buffer().is_empty());
+    ///     }
+    ///     Ok(())
+    /// }
+    /// ```
+    #[stable(feature = "bufreader_buffer", since = "1.37.0")]
+    pub fn buffer(&self) -> &[u8] {
+        self.buf.buffer()
+    }
+
+    /// Returns the number of bytes the internal buffer can hold at once.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use std::io::{BufReader, BufRead};
+    /// use std::fs::File;
+    ///
+    /// fn main() -> std::io::Result<()> {
+    ///     let f = File::open("log.txt")?;
+    ///     let mut reader = BufReader::new(f);
+    ///
+    ///     let capacity = reader.capacity();
+    ///     let buffer = reader.fill_buf()?;
+    ///     assert!(buffer.len() <= capacity);
+    ///     Ok(())
+    /// }
+    /// ```
+    #[stable(feature = "buffered_io_capacity", since = "1.46.0")]
+    pub fn capacity(&self) -> usize {
+        self.buf.capacity()
+    }
+
+    /// Unwraps this `BufReader<R>`, returning the underlying reader.
+    ///
+    /// Note that any leftover data in the internal buffer is lost. Therefore,
+    /// a following read from the underlying reader may lead to data loss.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use std::io::BufReader;
+    /// use std::fs::File;
+    ///
+    /// fn main() -> std::io::Result<()> {
+    ///     let f1 = File::open("log.txt")?;
+    ///     let reader = BufReader::new(f1);
+    ///
+    ///     let f2 = reader.into_inner();
+    ///     Ok(())
+    /// }
+    /// ```
+    #[stable(feature = "rust1", since = "1.0.0")]
+    pub fn into_inner(self) -> R
+    where
+        R: Sized,
+    {
+        self.inner
+    }
+
+    /// Invalidates all data in the internal buffer.
+    #[inline]
+    pub(in crate::io) fn discard_buffer(&mut self) {
+        self.buf.discard_buffer()
+    }
+}
+
+// This is only used by a test which asserts that the initialization-tracking is correct.
+#[cfg(test)]
+impl<R: ?Sized> BufReader<R> {
+    #[allow(missing_docs)]
+    pub fn initialized(&self) -> usize {
+        self.buf.initialized()
+    }
+}
+
+impl<R: ?Sized + Seek> BufReader<R> {
+    /// Seeks relative to the current position. If the new position lies within the buffer,
+    /// the buffer will not be flushed, allowing for more efficient seeks.
+    /// This method does not return the location of the underlying reader, so the caller
+    /// must track this information themselves if it is required.
+    #[stable(feature = "bufreader_seek_relative", since = "1.53.0")]
+    pub fn seek_relative(&mut self, offset: i64) -> io::Result<()> {
+        let pos = self.buf.pos() as u64;
+        if offset < 0 {
+            if let Some(_) = pos.checked_sub((-offset) as u64) {
+                self.buf.unconsume((-offset) as usize);
+                return Ok(());
+            }
+        } else if let Some(new_pos) = pos.checked_add(offset as u64) {
+            if new_pos <= self.buf.filled() as u64 {
+                self.buf.consume(offset as usize);
+                return Ok(());
+            }
+        }
+
+        self.seek(SeekFrom::Current(offset)).map(drop)
+    }
+}
+
+impl<R> SpecReadByte for BufReader<R>
+where
+    Self: Read,
+{
+    #[inline]
+    fn spec_read_byte(&mut self) -> Option<io::Result<u8>> {
+        let mut byte = 0;
+        if self.buf.consume_with(1, |claimed| byte = claimed[0]) {
+            return Some(Ok(byte));
+        }
+
+        // Fallback case, only reached once per buffer refill.
+        uninlined_slow_read_byte(self)
+    }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<R: ?Sized + Read> Read for BufReader<R> {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        // If we don't have any buffered data and we're doing a massive read
+        // (larger than our internal buffer), bypass our internal buffer
+        // entirely.
+        if self.buf.pos() == self.buf.filled() && buf.len() >= self.capacity() {
+            self.discard_buffer();
+            return self.inner.read(buf);
+        }
+        let mut rem = self.fill_buf()?;
+        let nread = rem.read(buf)?;
+        self.consume(nread);
+        Ok(nread)
+    }
+
+    fn read_buf(&mut self, mut cursor: BorrowedCursor<'_>) -> io::Result<()> {
+        // If we don't have any buffered data and we're doing a massive read
+        // (larger than our internal buffer), bypass our internal buffer
+        // entirely.
+        if self.buf.pos() == self.buf.filled() && cursor.capacity() >= self.capacity() {
+            self.discard_buffer();
+            return self.inner.read_buf(cursor);
+        }
+
+        let prev = cursor.written();
+
+        let mut rem = self.fill_buf()?;
+        rem.read_buf(cursor.reborrow())?; // actually never fails
+
+        self.consume(cursor.written() - prev); //slice impl of read_buf known to never unfill buf
+
+        Ok(())
+    }
+
+    // Small read_exacts from a BufReader are extremely common when used with a deserializer.
+    // The default implementation calls read in a loop, which results in surprisingly poor code
+    // generation for the common path where the buffer has enough bytes to fill the passed-in
+    // buffer.
+    fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
+        if self.buf.consume_with(buf.len(), |claimed| buf.copy_from_slice(claimed)) {
+            return Ok(());
+        }
+
+        crate::io::default_read_exact(self, buf)
+    }
+
+    fn read_buf_exact(&mut self, mut cursor: BorrowedCursor<'_>) -> io::Result<()> {
+        if self.buf.consume_with(cursor.capacity(), |claimed| cursor.append(claimed)) {
+            return Ok(());
+        }
+
+        crate::io::default_read_buf_exact(self, cursor)
+    }
+
+    fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
+        let total_len = bufs.iter().map(|b| b.len()).sum::<usize>();
+        if self.buf.pos() == self.buf.filled() && total_len >= self.capacity() {
+            self.discard_buffer();
+            return self.inner.read_vectored(bufs);
+        }
+        let mut rem = self.fill_buf()?;
+        let nread = rem.read_vectored(bufs)?;
+
+        self.consume(nread);
+        Ok(nread)
+    }
+
+    fn is_read_vectored(&self) -> bool {
+        self.inner.is_read_vectored()
+    }
+
+    // The inner reader might have an optimized `read_to_end`. Drain our buffer and then
+    // delegate to the inner implementation.
+    fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
+        let inner_buf = self.buffer();
+        buf.try_reserve(inner_buf.len())?;
+        buf.extend_from_slice(inner_buf);
+        let nread = inner_buf.len();
+        self.discard_buffer();
+        Ok(nread + self.inner.read_to_end(buf)?)
+    }
+
+    // The inner reader might have an optimized `read_to_end`. Drain our buffer and then
+    // delegate to the inner implementation.
+    fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> {
+        // In the general `else` case below we must read bytes into a side buffer, check
+        // that they are valid UTF-8, and then append them to `buf`. This requires a
+        // potentially large memcpy.
+        //
+        // If `buf` is empty--the most common case--we can leverage `append_to_string`
+        // to read directly into `buf`'s internal byte buffer, saving an allocation and
+        // a memcpy.
+        if buf.is_empty() {
+            // `append_to_string`'s safety relies on the buffer only being appended to since
+            // it only checks the UTF-8 validity of new data. If there were existing content in
+            // `buf` then an untrustworthy reader (i.e. `self.inner`) could not only append
+            // bytes but also modify existing bytes and render them invalid. On the other hand,
+            // if `buf` is empty then by definition any writes must be appends and
+            // `append_to_string` will validate all of the new bytes.
+            unsafe { crate::io::append_to_string(buf, |b| self.read_to_end(b)) }
+        } else {
+            // We cannot append our byte buffer directly onto the `buf` String as there could
+            // be an incomplete UTF-8 sequence that has only been partially read. We must read
+            // everything into a side buffer first and then call `from_utf8` on the complete
+            // buffer.
+            let mut bytes = Vec::new();
+            self.read_to_end(&mut bytes)?;
+            let string = crate::str::from_utf8(&bytes).map_err(|_| io::Error::INVALID_UTF8)?;
+            *buf += string;
+            Ok(string.len())
+        }
+    }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<R: ?Sized + Read> BufRead for BufReader<R> {
+    fn fill_buf(&mut self) -> io::Result<&[u8]> {
+        self.buf.fill_buf(&mut self.inner)
+    }
+
+    fn consume(&mut self, amt: usize) {
+        self.buf.consume(amt)
+    }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<R> fmt::Debug for BufReader<R>
+where
+    R: ?Sized + fmt::Debug,
+{
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt.debug_struct("BufReader")
+            .field("reader", &&self.inner)
+            .field(
+                "buffer",
+                &format_args!("{}/{}", self.buf.filled() - self.buf.pos(), self.capacity()),
+            )
+            .finish()
+    }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<R: ?Sized + Seek> Seek for BufReader<R> {
+    /// Seek to an offset, in bytes, in the underlying reader.
+    ///
+    /// The position used for seeking with <code>[SeekFrom::Current]\(_)</code> is the
+    /// position the underlying reader would be at if the `BufReader<R>` had no
+    /// internal buffer.
+    ///
+    /// Seeking always discards the internal buffer, even if the seek position
+    /// would otherwise fall within it. This guarantees that calling
+    /// [`BufReader::into_inner()`] immediately after a seek yields the underlying reader
+    /// at the same position.
+    ///
+    /// To seek without discarding the internal buffer, use [`BufReader::seek_relative`].
+    ///
+    /// See [`std::io::Seek`] for more details.
+    ///
+    /// Note: In the edge case where you're seeking with <code>[SeekFrom::Current]\(n)</code>
+    /// where `n` minus the internal buffer length overflows an `i64`, two
+    /// seeks will be performed instead of one. If the second seek returns
+    /// [`Err`], the underlying reader will be left at the same position it would
+    /// have if you called `seek` with <code>[SeekFrom::Current]\(0)</code>.
+    ///
+    /// [`std::io::Seek`]: Seek
+    fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
+        let result: u64;
+        if let SeekFrom::Current(n) = pos {
+            let remainder = (self.buf.filled() - self.buf.pos()) as i64;
+            // it should be safe to assume that remainder fits within an i64 as the alternative
+            // means we managed to allocate 8 exbibytes and that's absurd.
+            // But it's not out of the realm of possibility for some weird underlying reader to
+            // support seeking by i64::MIN so we need to handle underflow when subtracting
+            // remainder.
+            if let Some(offset) = n.checked_sub(remainder) {
+                result = self.inner.seek(SeekFrom::Current(offset))?;
+            } else {
+                // seek backwards by our remainder, and then by the offset
+                self.inner.seek(SeekFrom::Current(-remainder))?;
+                self.discard_buffer();
+                result = self.inner.seek(SeekFrom::Current(n))?;
+            }
+        } else {
+            // Seeking with Start/End doesn't care about our buffer length.
+            result = self.inner.seek(pos)?;
+        }
+        self.discard_buffer();
+        Ok(result)
+    }
+
+    /// Returns the current seek position from the start of the stream.
+    ///
+    /// The value returned is equivalent to `self.seek(SeekFrom::Current(0))`
+    /// but does not flush the internal buffer. Due to this optimization the
+    /// function does not guarantee that calling `.into_inner()` immediately
+    /// afterwards will yield the underlying reader at the same position. Use
+    /// [`BufReader::seek`] instead if you require that guarantee.
+    ///
+    /// # Panics
+    ///
+    /// This function will panic if the position of the inner reader is smaller
+    /// than the amount of buffered data. That can happen if the inner reader
+    /// has an incorrect implementation of [`Seek::stream_position`], or if the
+    /// position has gone out of sync due to calling [`Seek::seek`] directly on
+    /// the underlying reader.
+    ///
+    /// # Example
+    ///
+    /// ```no_run
+    /// use std::{
+    ///     io::{self, BufRead, BufReader, Seek},
+    ///     fs::File,
+    /// };
+    ///
+    /// fn main() -> io::Result<()> {
+    ///     let mut f = BufReader::new(File::open("foo.txt")?);
+    ///
+    ///     let before = f.stream_position()?;
+    ///     f.read_line(&mut String::new())?;
+    ///     let after = f.stream_position()?;
+    ///
+    ///     println!("The first line was {} bytes long", after - before);
+    ///     Ok(())
+    /// }
+    /// ```
+    fn stream_position(&mut self) -> io::Result<u64> {
+        let remainder = (self.buf.filled() - self.buf.pos()) as u64;
+        self.inner.stream_position().map(|pos| {
+            pos.checked_sub(remainder).expect(
+                "overflow when subtracting remaining buffer size from inner stream position",
+            )
+        })
+    }
+
+    /// Seeks relative to the current position.
+    ///
+    /// If the new position lies within the buffer, the buffer will not be
+    /// flushed, allowing for more efficient seeks. This method does not return
+    /// the location of the underlying reader, so the caller must track this
+    /// information themselves if it is required.
+    fn seek_relative(&mut self, offset: i64) -> io::Result<()> {
+        self.seek_relative(offset)
+    }
+}
+
+impl<T: ?Sized> SizeHint for BufReader<T> {
+    #[inline]
+    fn lower_bound(&self) -> usize {
+        SizeHint::lower_bound(self.get_ref()) + self.buffer().len()
+    }
+
+    #[inline]
+    fn upper_bound(&self) -> Option<usize> {
+        SizeHint::upper_bound(self.get_ref()).and_then(|up| self.buffer().len().checked_add(up))
+    }
+}

crates/io/src/io/buffered/bufreader/buffer.rs

@@ -0,0 +1,155 @@
+//! An encapsulation of `BufReader`'s buffer management logic.
+//!
+//! This module factors out the basic functionality of `BufReader` in order to protect two core
+//! invariants:
+//! * `filled` bytes of `buf` are always initialized
+//! * `pos` is always <= `filled`
+//! Since this module encapsulates the buffer management logic, we can ensure that the range
+//! `pos..filled` is always a valid index into the initialized region of the buffer. This means
+//! that user code which wants to do reads from a `BufReader` via `buffer` + `consume` can do so
+//! without encountering any runtime bounds checks.
+
+use crate::cmp;
+use crate::io::{self, BorrowedBuf, ErrorKind, Read};
+use crate::mem::MaybeUninit;
+
+pub struct Buffer {
+    // The buffer.
+    buf: Box<[MaybeUninit<u8>]>,
+    // The current seek offset into `buf`, must always be <= `filled`.
+    pos: usize,
+    // Each call to `fill_buf` sets `filled` to indicate how many bytes at the start of `buf` are
+    // initialized with bytes from a read.
+    filled: usize,
+    // This is the max number of bytes returned across all `fill_buf` calls. We track this so that we
+    // can accurately tell `read_buf` how many bytes of buf are initialized, to bypass as much of its
+    // defensive initialization as possible. Note that while this often the same as `filled`, it
+    // doesn't need to be. Calls to `fill_buf` are not required to actually fill the buffer, and
+    // omitting this is a huge perf regression for `Read` impls that do not.
+    initialized: usize,
+}
+
+impl Buffer {
+    #[inline]
+    pub fn with_capacity(capacity: usize) -> Self {
+        let buf = Box::new_uninit_slice(capacity);
+        Self { buf, pos: 0, filled: 0, initialized: 0 }
+    }
+
+    #[inline]
+    pub 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: 0 }),
+            Err(_) => {
+                Err(io::const_error!(ErrorKind::OutOfMemory, "failed to allocate read buffer"))
+            }
+        }
+    }
+
+    #[inline]
+    pub 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 {
+        self.buf.len()
+    }
+
+    #[inline]
+    pub fn filled(&self) -> usize {
+        self.filled
+    }
+
+    #[inline]
+    pub fn pos(&self) -> usize {
+        self.pos
+    }
+
+    // This is only used by a test which asserts that the initialization-tracking is correct.
+    #[cfg(test)]
+    pub fn initialized(&self) -> usize {
+        self.initialized
+    }
+
+    #[inline]
+    pub fn discard_buffer(&mut self) {
+        self.pos = 0;
+        self.filled = 0;
+    }
+
+    #[inline]
+    pub 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
+    where
+        V: FnMut(&[u8]),
+    {
+        if let Some(claimed) = self.buffer().get(..amt) {
+            visitor(claimed);
+            // If the indexing into self.buffer() succeeds, amt must be a valid increment.
+            self.pos += amt;
+            true
+        } else {
+            false
+        }
+    }
+
+    #[inline]
+    pub 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> {
+        let mut buf = BorrowedBuf::from(&mut self.buf[self.filled..]);
+        let old_init = self.initialized - self.filled;
+        unsafe {
+            buf.set_init(old_init);
+        }
+        reader.read_buf(buf.unfilled())?;
+        self.filled += buf.len();
+        self.initialized += buf.init_len() - old_init;
+        Ok(buf.len())
+    }
+
+    /// Remove bytes that have already been read from the buffer.
+    pub 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]> {
+        // 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 `==`
+        // to tell the compiler that the pos..cap slice is always valid.
+        if self.pos >= self.filled {
+            debug_assert!(self.pos == self.filled);
+
+            let mut buf = BorrowedBuf::from(&mut *self.buf);
+            // SAFETY: `self.filled` bytes will always have been initialized.
+            unsafe {
+                buf.set_init(self.initialized);
+            }
+
+            let result = reader.read_buf(buf.unfilled());
+
+            self.pos = 0;
+            self.filled = buf.len();
+            self.initialized = buf.init_len();
+
+            result?;
+        }
+        Ok(self.buffer())
+    }
+}

crates/io/src/io/buffered/bufwriter.rs

@@ -0,0 +1,680 @@
+use crate::io::{
+    self, DEFAULT_BUF_SIZE, ErrorKind, IntoInnerError, IoSlice, Seek, SeekFrom, Write,
+};
+use crate::mem::{self, ManuallyDrop};
+use crate::{error, fmt, ptr};
+
+/// Wraps a writer and buffers its output.
+///
+/// It can be excessively inefficient to work directly with something that
+/// implements [`Write`]. For example, every call to
+/// [`write`][`TcpStream::write`] on [`TcpStream`] results in a system call. A
+/// `BufWriter<W>` keeps an in-memory buffer of data and writes it to an underlying
+/// writer in large, infrequent batches.
+///
+/// `BufWriter<W>` can improve the speed of programs that make *small* and
+/// *repeated* write calls to the same file or network socket. It does not
+/// help when writing very large amounts at once, or writing just one or a few
+/// times. It also provides no advantage when writing to a destination that is
+/// in memory, like a <code>[Vec]\<u8></code>.
+///
+/// It is critical to call [`flush`] before `BufWriter<W>` is dropped. Though
+/// dropping will attempt to flush the contents of the buffer, any errors
+/// that happen in the process of dropping will be ignored. Calling [`flush`]
+/// ensures that the buffer is empty and thus dropping will not even attempt
+/// file operations.
+///
+/// # Examples
+///
+/// Let's write the numbers one through ten to a [`TcpStream`]:
+///
+/// ```no_run
+/// use std::io::prelude::*;
+/// use std::net::TcpStream;
+///
+/// let mut stream = TcpStream::connect("127.0.0.1:34254").unwrap();
+///
+/// for i in 0..10 {
+///     stream.write(&[i+1]).unwrap();
+/// }
+/// ```
+///
+/// Because we're not buffering, we write each one in turn, incurring the
+/// overhead of a system call per byte written. We can fix this with a
+/// `BufWriter<W>`:
+///
+/// ```no_run
+/// use std::io::prelude::*;
+/// use std::io::BufWriter;
+/// use std::net::TcpStream;
+///
+/// let mut stream = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
+///
+/// for i in 0..10 {
+///     stream.write(&[i+1]).unwrap();
+/// }
+/// stream.flush().unwrap();
+/// ```
+///
+/// By wrapping the stream with a `BufWriter<W>`, these ten writes are all grouped
+/// together by the buffer and will all be written out in one system call when
+/// the `stream` is flushed.
+///
+/// [`TcpStream::write`]: crate::net::TcpStream::write
+/// [`TcpStream`]: crate::net::TcpStream
+/// [`flush`]: BufWriter::flush
+#[stable(feature = "rust1", since = "1.0.0")]
+pub struct BufWriter<W: ?Sized + Write> {
+    // The buffer. Avoid using this like a normal `Vec` in common code paths.
+    // That is, don't use `buf.push`, `buf.extend_from_slice`, or any other
+    // methods that require bounds checking or the like. This makes an enormous
+    // difference to performance (we may want to stop using a `Vec` entirely).
+    buf: Vec<u8>,
+    // #30888: If the inner writer panics in a call to write, we don't want to
+    // write the buffered data a second time in BufWriter's destructor. This
+    // flag tells the Drop impl if it should skip the flush.
+    panicked: bool,
+    inner: W,
+}
+
+impl<W: Write> BufWriter<W> {
+    /// Creates a new `BufWriter<W>` with a default buffer capacity. The default is currently 8 KiB,
+    /// but may change in the future.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use std::io::BufWriter;
+    /// use std::net::TcpStream;
+    ///
+    /// let mut buffer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
+    /// ```
+    #[stable(feature = "rust1", since = "1.0.0")]
+    pub fn new(inner: W) -> BufWriter<W> {
+        BufWriter::with_capacity(DEFAULT_BUF_SIZE, inner)
+    }
+
+    pub(crate) fn try_new_buffer() -> io::Result<Vec<u8>> {
+        Vec::try_with_capacity(DEFAULT_BUF_SIZE).map_err(|_| {
+            io::const_error!(ErrorKind::OutOfMemory, "failed to allocate write buffer")
+        })
+    }
+
+    pub(crate) fn with_buffer(inner: W, buf: Vec<u8>) -> Self {
+        Self { inner, buf, panicked: false }
+    }
+
+    /// Creates a new `BufWriter<W>` with at least the specified buffer capacity.
+    ///
+    /// # Examples
+    ///
+    /// Creating a buffer with a buffer of at least a hundred bytes.
+    ///
+    /// ```no_run
+    /// use std::io::BufWriter;
+    /// use std::net::TcpStream;
+    ///
+    /// let stream = TcpStream::connect("127.0.0.1:34254").unwrap();
+    /// let mut buffer = BufWriter::with_capacity(100, stream);
+    /// ```
+    #[stable(feature = "rust1", since = "1.0.0")]
+    pub fn with_capacity(capacity: usize, inner: W) -> BufWriter<W> {
+        BufWriter { inner, buf: Vec::with_capacity(capacity), panicked: false }
+    }
+
+    /// Unwraps this `BufWriter<W>`, returning the underlying writer.
+    ///
+    /// The buffer is written out before returning the writer.
+    ///
+    /// # Errors
+    ///
+    /// An [`Err`] will be returned if an error occurs while flushing the buffer.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use std::io::BufWriter;
+    /// use std::net::TcpStream;
+    ///
+    /// let mut buffer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
+    ///
+    /// // unwrap the TcpStream and flush the buffer
+    /// let stream = buffer.into_inner().unwrap();
+    /// ```
+    #[stable(feature = "rust1", since = "1.0.0")]
+    pub fn into_inner(mut self) -> Result<W, IntoInnerError<BufWriter<W>>> {
+        match self.flush_buf() {
+            Err(e) => Err(IntoInnerError::new(self, e)),
+            Ok(()) => Ok(self.into_parts().0),
+        }
+    }
+
+    /// Disassembles this `BufWriter<W>`, returning the underlying writer, and any buffered but
+    /// unwritten data.
+    ///
+    /// If the underlying writer panicked, it is not known what portion of the data was written.
+    /// In this case, we return `WriterPanicked` for the buffered data (from which the buffer
+    /// contents can still be recovered).
+    ///
+    /// `into_parts` makes no attempt to flush data and cannot fail.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::io::{BufWriter, Write};
+    ///
+    /// let mut buffer = [0u8; 10];
+    /// let mut stream = BufWriter::new(buffer.as_mut());
+    /// write!(stream, "too much data").unwrap();
+    /// stream.flush().expect_err("it doesn't fit");
+    /// let (recovered_writer, buffered_data) = stream.into_parts();
+    /// assert_eq!(recovered_writer.len(), 0);
+    /// assert_eq!(&buffered_data.unwrap(), b"ata");
+    /// ```
+    #[stable(feature = "bufwriter_into_parts", since = "1.56.0")]
+    pub fn into_parts(self) -> (W, Result<Vec<u8>, WriterPanicked>) {
+        let mut this = ManuallyDrop::new(self);
+        let buf = mem::take(&mut this.buf);
+        let buf = if !this.panicked { Ok(buf) } else { Err(WriterPanicked { buf }) };
+
+        // SAFETY: double-drops are prevented by putting `this` in a ManuallyDrop that is never dropped
+        let inner = unsafe { ptr::read(&this.inner) };
+
+        (inner, buf)
+    }
+}
+
+impl<W: ?Sized + Write> BufWriter<W> {
+    /// Send data in our local buffer into the inner writer, looping as
+    /// necessary until either it's all been sent or an error occurs.
+    ///
+    /// Because all the data in the buffer has been reported to our owner as
+    /// "successfully written" (by returning nonzero success values from
+    /// `write`), any 0-length writes from `inner` must be reported as i/o
+    /// errors from this method.
+    pub(in crate::io) fn flush_buf(&mut self) -> io::Result<()> {
+        /// Helper struct to ensure the buffer is updated after all the writes
+        /// are complete. It tracks the number of written bytes and drains them
+        /// all from the front of the buffer when dropped.
+        struct BufGuard<'a> {
+            buffer: &'a mut Vec<u8>,
+            written: usize,
+        }
+
+        impl<'a> BufGuard<'a> {
+            fn new(buffer: &'a mut Vec<u8>) -> Self {
+                Self { buffer, written: 0 }
+            }
+
+            /// The unwritten part of the buffer
+            fn remaining(&self) -> &[u8] {
+                &self.buffer[self.written..]
+            }
+
+            /// Flag some bytes as removed from the front of the buffer
+            fn consume(&mut self, amt: usize) {
+                self.written += amt;
+            }
+
+            /// true if all of the bytes have been written
+            fn done(&self) -> bool {
+                self.written >= self.buffer.len()
+            }
+        }
+
+        impl Drop for BufGuard<'_> {
+            fn drop(&mut self) {
+                if self.written > 0 {
+                    self.buffer.drain(..self.written);
+                }
+            }
+        }
+
+        let mut guard = BufGuard::new(&mut self.buf);
+        while !guard.done() {
+            self.panicked = true;
+            let r = self.inner.write(guard.remaining());
+            self.panicked = false;
+
+            match r {
+                Ok(0) => {
+                    return Err(io::const_error!(
+                        ErrorKind::WriteZero,
+                        "failed to write the buffered data",
+                    ));
+                }
+                Ok(n) => guard.consume(n),
+                Err(ref e) if e.is_interrupted() => {}
+                Err(e) => return Err(e),
+            }
+        }
+        Ok(())
+    }
+
+    /// Buffer some data without flushing it, regardless of the size of the
+    /// data. Writes as much as possible without exceeding capacity. Returns
+    /// the number of bytes written.
+    pub(super) fn write_to_buf(&mut self, buf: &[u8]) -> usize {
+        let available = self.spare_capacity();
+        let amt_to_buffer = available.min(buf.len());
+
+        // SAFETY: `amt_to_buffer` is <= buffer's spare capacity by construction.
+        unsafe {
+            self.write_to_buffer_unchecked(&buf[..amt_to_buffer]);
+        }
+
+        amt_to_buffer
+    }
+
+    /// Gets a reference to the underlying writer.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use std::io::BufWriter;
+    /// use std::net::TcpStream;
+    ///
+    /// let mut buffer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
+    ///
+    /// // we can use reference just like buffer
+    /// let reference = buffer.get_ref();
+    /// ```
+    #[stable(feature = "rust1", since = "1.0.0")]
+    pub fn get_ref(&self) -> &W {
+        &self.inner
+    }
+
+    /// Gets a mutable reference to the underlying writer.
+    ///
+    /// It is inadvisable to directly write to the underlying writer.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use std::io::BufWriter;
+    /// use std::net::TcpStream;
+    ///
+    /// let mut buffer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
+    ///
+    /// // we can use reference just like buffer
+    /// let reference = buffer.get_mut();
+    /// ```
+    #[stable(feature = "rust1", since = "1.0.0")]
+    pub fn get_mut(&mut self) -> &mut W {
+        &mut self.inner
+    }
+
+    /// Returns a reference to the internally buffered data.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use std::io::BufWriter;
+    /// use std::net::TcpStream;
+    ///
+    /// let buf_writer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
+    ///
+    /// // See how many bytes are currently buffered
+    /// let bytes_buffered = buf_writer.buffer().len();
+    /// ```
+    #[stable(feature = "bufreader_buffer", since = "1.37.0")]
+    pub fn buffer(&self) -> &[u8] {
+        &self.buf
+    }
+
+    /// Returns a mutable reference to the internal buffer.
+    ///
+    /// This can be used to write data directly into the buffer without triggering writers
+    /// to the underlying writer.
+    ///
+    /// That the buffer is a `Vec` is an implementation detail.
+    /// Callers should not modify the capacity as there currently is no public API to do so
+    /// and thus any capacity changes would be unexpected by the user.
+    pub(in crate::io) fn buffer_mut(&mut self) -> &mut Vec<u8> {
+        &mut self.buf
+    }
+
+    /// Returns the number of bytes the internal buffer can hold without flushing.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use std::io::BufWriter;
+    /// use std::net::TcpStream;
+    ///
+    /// let buf_writer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
+    ///
+    /// // Check the capacity of the inner buffer
+    /// let capacity = buf_writer.capacity();
+    /// // Calculate how many bytes can be written without flushing
+    /// let without_flush = capacity - buf_writer.buffer().len();
+    /// ```
+    #[stable(feature = "buffered_io_capacity", since = "1.46.0")]
+    pub fn capacity(&self) -> usize {
+        self.buf.capacity()
+    }
+
+    // Ensure this function does not get inlined into `write`, so that it
+    // remains inlineable and its common path remains as short as possible.
+    // If this function ends up being called frequently relative to `write`,
+    // it's likely a sign that the client is using an improperly sized buffer
+    // or their write patterns are somewhat pathological.
+    #[cold]
+    #[inline(never)]
+    fn write_cold(&mut self, buf: &[u8]) -> io::Result<usize> {
+        if buf.len() > self.spare_capacity() {
+            self.flush_buf()?;
+        }
+
+        // Why not len > capacity? To avoid a needless trip through the buffer when the input
+        // exactly fills it. We'd just need to flush it to the underlying writer anyway.
+        if buf.len() >= self.buf.capacity() {
+            self.panicked = true;
+            let r = self.get_mut().write(buf);
+            self.panicked = false;
+            r
+        } else {
+            // Write to the buffer. In this case, we write to the buffer even if it fills it
+            // exactly. Doing otherwise would mean flushing the buffer, then writing this
+            // input to the inner writer, which in many cases would be a worse strategy.
+
+            // SAFETY: There was either enough spare capacity already, or there wasn't and we
+            // flushed the buffer to ensure that there is. In the latter case, we know that there
+            // is because flushing ensured that our entire buffer is spare capacity, and we entered
+            // this block because the input buffer length is less than that capacity. In either
+            // case, it's safe to write the input buffer to our buffer.
+            unsafe {
+                self.write_to_buffer_unchecked(buf);
+            }
+
+            Ok(buf.len())
+        }
+    }
+
+    // Ensure this function does not get inlined into `write_all`, so that it
+    // remains inlineable and its common path remains as short as possible.
+    // If this function ends up being called frequently relative to `write_all`,
+    // it's likely a sign that the client is using an improperly sized buffer
+    // or their write patterns are somewhat pathological.
+    #[cold]
+    #[inline(never)]
+    fn write_all_cold(&mut self, buf: &[u8]) -> io::Result<()> {
+        // Normally, `write_all` just calls `write` in a loop. We can do better
+        // by calling `self.get_mut().write_all()` directly, which avoids
+        // round trips through the buffer in the event of a series of partial
+        // writes in some circumstances.
+
+        if buf.len() > self.spare_capacity() {
+            self.flush_buf()?;
+        }
+
+        // Why not len > capacity? To avoid a needless trip through the buffer when the input
+        // exactly fills it. We'd just need to flush it to the underlying writer anyway.
+        if buf.len() >= self.buf.capacity() {
+            self.panicked = true;
+            let r = self.get_mut().write_all(buf);
+            self.panicked = false;
+            r
+        } else {
+            // Write to the buffer. In this case, we write to the buffer even if it fills it
+            // exactly. Doing otherwise would mean flushing the buffer, then writing this
+            // input to the inner writer, which in many cases would be a worse strategy.
+
+            // SAFETY: There was either enough spare capacity already, or there wasn't and we
+            // flushed the buffer to ensure that there is. In the latter case, we know that there
+            // is because flushing ensured that our entire buffer is spare capacity, and we entered
+            // this block because the input buffer length is less than that capacity. In either
+            // case, it's safe to write the input buffer to our buffer.
+            unsafe {
+                self.write_to_buffer_unchecked(buf);
+            }
+
+            Ok(())
+        }
+    }
+
+    // SAFETY: Requires `buf.len() <= self.buf.capacity() - self.buf.len()`,
+    // i.e., that input buffer length is less than or equal to spare capacity.
+    #[inline]
+    unsafe fn write_to_buffer_unchecked(&mut self, buf: &[u8]) {
+        debug_assert!(buf.len() <= self.spare_capacity());
+        let old_len = self.buf.len();
+        let buf_len = buf.len();
+        let src = buf.as_ptr();
+        unsafe {
+            let dst = self.buf.as_mut_ptr().add(old_len);
+            ptr::copy_nonoverlapping(src, dst, buf_len);
+            self.buf.set_len(old_len + buf_len);
+        }
+    }
+
+    #[inline]
+    fn spare_capacity(&self) -> usize {
+        self.buf.capacity() - self.buf.len()
+    }
+}
+
+#[stable(feature = "bufwriter_into_parts", since = "1.56.0")]
+/// Error returned for the buffered data from `BufWriter::into_parts`, when the underlying
+/// writer has previously panicked.  Contains the (possibly partly written) buffered data.
+///
+/// # Example
+///
+/// ```
+/// use std::io::{self, BufWriter, Write};
+/// use std::panic::{catch_unwind, AssertUnwindSafe};
+///
+/// struct PanickingWriter;
+/// impl Write for PanickingWriter {
+///   fn write(&mut self, buf: &[u8]) -> io::Result<usize> { panic!() }
+///   fn flush(&mut self) -> io::Result<()> { panic!() }
+/// }
+///
+/// let mut stream = BufWriter::new(PanickingWriter);
+/// write!(stream, "some data").unwrap();
+/// let result = catch_unwind(AssertUnwindSafe(|| {
+///     stream.flush().unwrap()
+/// }));
+/// assert!(result.is_err());
+/// let (recovered_writer, buffered_data) = stream.into_parts();
+/// assert!(matches!(recovered_writer, PanickingWriter));
+/// assert_eq!(buffered_data.unwrap_err().into_inner(), b"some data");
+/// ```
+pub struct WriterPanicked {
+    buf: Vec<u8>,
+}
+
+impl WriterPanicked {
+    /// Returns the perhaps-unwritten data.  Some of this data may have been written by the
+    /// panicking call(s) to the underlying writer, so simply writing it again is not a good idea.
+    #[must_use = "`self` will be dropped if the result is not used"]
+    #[stable(feature = "bufwriter_into_parts", since = "1.56.0")]
+    pub fn into_inner(self) -> Vec<u8> {
+        self.buf
+    }
+}
+
+#[stable(feature = "bufwriter_into_parts", since = "1.56.0")]
+impl error::Error for WriterPanicked {}
+
+#[stable(feature = "bufwriter_into_parts", since = "1.56.0")]
+impl fmt::Display for WriterPanicked {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        "BufWriter inner writer panicked, what data remains unwritten is not known".fmt(f)
+    }
+}
+
+#[stable(feature = "bufwriter_into_parts", since = "1.56.0")]
+impl fmt::Debug for WriterPanicked {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("WriterPanicked")
+            .field("buffer", &format_args!("{}/{}", self.buf.len(), self.buf.capacity()))
+            .finish()
+    }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<W: ?Sized + Write> Write for BufWriter<W> {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        // Use < instead of <= to avoid a needless trip through the buffer in some cases.
+        // See `write_cold` for details.
+        if buf.len() < self.spare_capacity() {
+            // SAFETY: safe by above conditional.
+            unsafe {
+                self.write_to_buffer_unchecked(buf);
+            }
+
+            Ok(buf.len())
+        } else {
+            self.write_cold(buf)
+        }
+    }
+
+    #[inline]
+    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
+        // Use < instead of <= to avoid a needless trip through the buffer in some cases.
+        // See `write_all_cold` for details.
+        if buf.len() < self.spare_capacity() {
+            // SAFETY: safe by above conditional.
+            unsafe {
+                self.write_to_buffer_unchecked(buf);
+            }
+
+            Ok(())
+        } else {
+            self.write_all_cold(buf)
+        }
+    }
+
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        // FIXME: Consider applying `#[inline]` / `#[inline(never)]` optimizations already applied
+        // to `write` and `write_all`. The performance benefits can be significant. See #79930.
+        if self.get_ref().is_write_vectored() {
+            // We have to handle the possibility that the total length of the buffers overflows
+            // `usize` (even though this can only happen if multiple `IoSlice`s reference the
+            // same underlying buffer, as otherwise the buffers wouldn't fit in memory). If the
+            // computation overflows, then surely the input cannot fit in our buffer, so we forward
+            // to the inner writer's `write_vectored` method to let it handle it appropriately.
+            let mut saturated_total_len: usize = 0;
+
+            for buf in bufs {
+                saturated_total_len = saturated_total_len.saturating_add(buf.len());
+
+                if saturated_total_len > self.spare_capacity() && !self.buf.is_empty() {
+                    // Flush if the total length of the input exceeds our buffer's spare capacity.
+                    // If we would have overflowed, this condition also holds, and we need to flush.
+                    self.flush_buf()?;
+                }
+
+                if saturated_total_len >= self.buf.capacity() {
+                    // Forward to our inner writer if the total length of the input is greater than or
+                    // equal to our buffer capacity. If we would have overflowed, this condition also
+                    // holds, and we punt to the inner writer.
+                    self.panicked = true;
+                    let r = self.get_mut().write_vectored(bufs);
+                    self.panicked = false;
+                    return r;
+                }
+            }
+
+            // `saturated_total_len < self.buf.capacity()` implies that we did not saturate.
+
+            // SAFETY: We checked whether or not the spare capacity was large enough above. If
+            // it was, then we're safe already. If it wasn't, we flushed, making sufficient
+            // room for any input <= the buffer size, which includes this input.
+            unsafe {
+                bufs.iter().for_each(|b| self.write_to_buffer_unchecked(b));
+            };
+
+            Ok(saturated_total_len)
+        } else {
+            let mut iter = bufs.iter();
+            let mut total_written = if let Some(buf) = iter.by_ref().find(|&buf| !buf.is_empty()) {
+                // This is the first non-empty slice to write, so if it does
+                // not fit in the buffer, we still get to flush and proceed.
+                if buf.len() > self.spare_capacity() {
+                    self.flush_buf()?;
+                }
+                if buf.len() >= self.buf.capacity() {
+                    // The slice is at least as large as the buffering capacity,
+                    // so it's better to write it directly, bypassing the buffer.
+                    self.panicked = true;
+                    let r = self.get_mut().write(buf);
+                    self.panicked = false;
+                    return r;
+                } else {
+                    // SAFETY: We checked whether or not the spare capacity was large enough above.
+                    // If it was, then we're safe already. If it wasn't, we flushed, making
+                    // sufficient room for any input <= the buffer size, which includes this input.
+                    unsafe {
+                        self.write_to_buffer_unchecked(buf);
+                    }
+
+                    buf.len()
+                }
+            } else {
+                return Ok(0);
+            };
+            debug_assert!(total_written != 0);
+            for buf in iter {
+                if buf.len() <= self.spare_capacity() {
+                    // SAFETY: safe by above conditional.
+                    unsafe {
+                        self.write_to_buffer_unchecked(buf);
+                    }
+
+                    // This cannot overflow `usize`. If we are here, we've written all of the bytes
+                    // so far to our buffer, and we've ensured that we never exceed the buffer's
+                    // capacity. Therefore, `total_written` <= `self.buf.capacity()` <= `usize::MAX`.
+                    total_written += buf.len();
+                } else {
+                    break;
+                }
+            }
+            Ok(total_written)
+        }
+    }
+
+    fn is_write_vectored(&self) -> bool {
+        true
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        self.flush_buf().and_then(|()| self.get_mut().flush())
+    }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<W: ?Sized + Write> fmt::Debug for BufWriter<W>
+where
+    W: fmt::Debug,
+{
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt.debug_struct("BufWriter")
+            .field("writer", &&self.inner)
+            .field("buffer", &format_args!("{}/{}", self.buf.len(), self.buf.capacity()))
+            .finish()
+    }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<W: ?Sized + Write + Seek> Seek for BufWriter<W> {
+    /// Seek to the offset, in bytes, in the underlying writer.
+    ///
+    /// Seeking always writes out the internal buffer before seeking.
+    fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
+        self.flush_buf()?;
+        self.get_mut().seek(pos)
+    }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<W: ?Sized + Write> Drop for BufWriter<W> {
+    fn drop(&mut self) {
+        if !self.panicked {
+            // dtors should not panic, so we ignore a failed flush
+            let _r = self.flush_buf();
+        }
+    }
+}

crates/io/src/io/buffered/linewriter.rs

@@ -0,0 +1,235 @@
+use crate::fmt;
+use crate::io::buffered::LineWriterShim;
+use crate::io::{self, BufWriter, IntoInnerError, IoSlice, Write};
+
+/// Wraps a writer and buffers output to it, flushing whenever a newline
+/// (`0x0a`, `'\n'`) is detected.
+///
+/// The [`BufWriter`] struct wraps a writer and buffers its output.
+/// But it only does this batched write when it goes out of scope, or when the
+/// internal buffer is full. Sometimes, you'd prefer to write each line as it's
+/// completed, rather than the entire buffer at once. Enter `LineWriter`. It
+/// does exactly that.
+///
+/// Like [`BufWriter`], a `LineWriter`’s buffer will also be flushed when the
+/// `LineWriter` goes out of scope or when its internal buffer is full.
+///
+/// If there's still a partial line in the buffer when the `LineWriter` is
+/// dropped, it will flush those contents.
+///
+/// # Examples
+///
+/// We can use `LineWriter` to write one line at a time, significantly
+/// reducing the number of actual writes to the file.
+///
+/// ```no_run
+/// use std::fs::{self, File};
+/// use std::io::prelude::*;
+/// use std::io::LineWriter;
+///
+/// fn main() -> std::io::Result<()> {
+///     let road_not_taken = b"I shall be telling this with a sigh
+/// Somewhere ages and ages hence:
+/// Two roads diverged in a wood, and I -
+/// I took the one less traveled by,
+/// And that has made all the difference.";
+///
+///     let file = File::create("poem.txt")?;
+///     let mut file = LineWriter::new(file);
+///
+///     file.write_all(b"I shall be telling this with a sigh")?;
+///
+///     // No bytes are written until a newline is encountered (or
+///     // the internal buffer is filled).
+///     assert_eq!(fs::read_to_string("poem.txt")?, "");
+///     file.write_all(b"\n")?;
+///     assert_eq!(
+///         fs::read_to_string("poem.txt")?,
+///         "I shall be telling this with a sigh\n",
+///     );
+///
+///     // Write the rest of the poem.
+///     file.write_all(b"Somewhere ages and ages hence:
+/// Two roads diverged in a wood, and I -
+/// I took the one less traveled by,
+/// And that has made all the difference.")?;
+///
+///     // The last line of the poem doesn't end in a newline, so
+///     // we have to flush or drop the `LineWriter` to finish
+///     // writing.
+///     file.flush()?;
+///
+///     // Confirm the whole poem was written.
+///     assert_eq!(fs::read("poem.txt")?, &road_not_taken[..]);
+///     Ok(())
+/// }
+/// ```
+#[stable(feature = "rust1", since = "1.0.0")]
+pub struct LineWriter<W: ?Sized + Write> {
+    inner: BufWriter<W>,
+}
+
+impl<W: Write> LineWriter<W> {
+    /// Creates a new `LineWriter`.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use std::fs::File;
+    /// use std::io::LineWriter;
+    ///
+    /// fn main() -> std::io::Result<()> {
+    ///     let file = File::create("poem.txt")?;
+    ///     let file = LineWriter::new(file);
+    ///     Ok(())
+    /// }
+    /// ```
+    #[stable(feature = "rust1", since = "1.0.0")]
+    pub fn new(inner: W) -> LineWriter<W> {
+        // Lines typically aren't that long, don't use a giant buffer
+        LineWriter::with_capacity(1024, inner)
+    }
+
+    /// Creates a new `LineWriter` with at least the specified capacity for the
+    /// internal buffer.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use std::fs::File;
+    /// use std::io::LineWriter;
+    ///
+    /// fn main() -> std::io::Result<()> {
+    ///     let file = File::create("poem.txt")?;
+    ///     let file = LineWriter::with_capacity(100, file);
+    ///     Ok(())
+    /// }
+    /// ```
+    #[stable(feature = "rust1", since = "1.0.0")]
+    pub fn with_capacity(capacity: usize, inner: W) -> LineWriter<W> {
+        LineWriter { inner: BufWriter::with_capacity(capacity, inner) }
+    }
+
+    /// Gets a mutable reference to the underlying writer.
+    ///
+    /// Caution must be taken when calling methods on the mutable reference
+    /// returned as extra writes could corrupt the output stream.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use std::fs::File;
+    /// use std::io::LineWriter;
+    ///
+    /// fn main() -> std::io::Result<()> {
+    ///     let file = File::create("poem.txt")?;
+    ///     let mut file = LineWriter::new(file);
+    ///
+    ///     // we can use reference just like file
+    ///     let reference = file.get_mut();
+    ///     Ok(())
+    /// }
+    /// ```
+    #[stable(feature = "rust1", since = "1.0.0")]
+    pub fn get_mut(&mut self) -> &mut W {
+        self.inner.get_mut()
+    }
+
+    /// Unwraps this `LineWriter`, returning the underlying writer.
+    ///
+    /// The internal buffer is written out before returning the writer.
+    ///
+    /// # Errors
+    ///
+    /// An [`Err`] will be returned if an error occurs while flushing the buffer.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use std::fs::File;
+    /// use std::io::LineWriter;
+    ///
+    /// fn main() -> std::io::Result<()> {
+    ///     let file = File::create("poem.txt")?;
+    ///
+    ///     let writer: LineWriter<File> = LineWriter::new(file);
+    ///
+    ///     let file: File = writer.into_inner()?;
+    ///     Ok(())
+    /// }
+    /// ```
+    #[stable(feature = "rust1", since = "1.0.0")]
+    pub fn into_inner(self) -> Result<W, IntoInnerError<LineWriter<W>>> {
+        self.inner.into_inner().map_err(|err| err.new_wrapped(|inner| LineWriter { inner }))
+    }
+}
+
+impl<W: ?Sized + Write> LineWriter<W> {
+    /// Gets a reference to the underlying writer.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use std::fs::File;
+    /// use std::io::LineWriter;
+    ///
+    /// fn main() -> std::io::Result<()> {
+    ///     let file = File::create("poem.txt")?;
+    ///     let file = LineWriter::new(file);
+    ///
+    ///     let reference = file.get_ref();
+    ///     Ok(())
+    /// }
+    /// ```
+    #[stable(feature = "rust1", since = "1.0.0")]
+    pub fn get_ref(&self) -> &W {
+        self.inner.get_ref()
+    }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<W: ?Sized + Write> Write for LineWriter<W> {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        LineWriterShim::new(&mut self.inner).write(buf)
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        self.inner.flush()
+    }
+
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        LineWriterShim::new(&mut self.inner).write_vectored(bufs)
+    }
+
+    fn is_write_vectored(&self) -> bool {
+        self.inner.is_write_vectored()
+    }
+
+    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
+        LineWriterShim::new(&mut self.inner).write_all(buf)
+    }
+
+    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        LineWriterShim::new(&mut self.inner).write_all_vectored(bufs)
+    }
+
+    fn write_fmt(&mut self, fmt: fmt::Arguments<'_>) -> io::Result<()> {
+        LineWriterShim::new(&mut self.inner).write_fmt(fmt)
+    }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<W: ?Sized + Write> fmt::Debug for LineWriter<W>
+where
+    W: fmt::Debug,
+{
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt.debug_struct("LineWriter")
+            .field("writer", &self.get_ref())
+            .field(
+                "buffer",
+                &format_args!("{}/{}", self.inner.buffer().len(), self.inner.capacity()),
+            )
+            .finish_non_exhaustive()
+    }
+}

crates/io/src/io/buffered/linewritershim.rs

@@ -0,0 +1,297 @@
+use core::slice::memchr;
+
+use crate::io::{self, BufWriter, IoSlice, Write};
+
+/// Private helper struct for implementing the line-buffered writing logic.
+///
+/// This shim temporarily wraps a BufWriter, and uses its internals to
+/// implement a line-buffered writer (specifically by using the internal
+/// methods like write_to_buf and flush_buf). In this way, a more
+/// efficient abstraction can be created than one that only had access to
+/// `write` and `flush`, without needlessly duplicating a lot of the
+/// implementation details of BufWriter. This also allows existing
+/// `BufWriters` to be temporarily given line-buffering logic; this is what
+/// enables Stdout to be alternately in line-buffered or block-buffered mode.
+#[derive(Debug)]
+pub struct LineWriterShim<'a, W: ?Sized + Write> {
+    buffer: &'a mut BufWriter<W>,
+}
+
+impl<'a, W: ?Sized + Write> LineWriterShim<'a, W> {
+    pub fn new(buffer: &'a mut BufWriter<W>) -> Self {
+        Self { buffer }
+    }
+
+    /// Gets a reference to the inner writer (that is, the writer
+    /// wrapped by the BufWriter).
+    fn inner(&self) -> &W {
+        self.buffer.get_ref()
+    }
+
+    /// Gets a mutable reference to the inner writer (that is, the writer
+    /// wrapped by the BufWriter). Be careful with this writer, as writes to
+    /// it will bypass the buffer.
+    fn inner_mut(&mut self) -> &mut W {
+        self.buffer.get_mut()
+    }
+
+    /// Gets the content currently buffered in self.buffer
+    fn buffered(&self) -> &[u8] {
+        self.buffer.buffer()
+    }
+
+    /// Flushes the buffer iff the last byte is a newline (indicating that an
+    /// earlier write only succeeded partially, and we want to retry flushing
+    /// the buffered line before continuing with a subsequent write).
+    fn flush_if_completed_line(&mut self) -> io::Result<()> {
+        match self.buffered().last().copied() {
+            Some(b'\n') => self.buffer.flush_buf(),
+            _ => Ok(()),
+        }
+    }
+}
+
+impl<'a, W: ?Sized + Write> Write for LineWriterShim<'a, W> {
+    /// Writes some data into this BufWriter with line buffering.
+    ///
+    /// This means that, if any newlines are present in the data, the data up to
+    /// the last newline is sent directly to the underlying writer, and data
+    /// after it is buffered. Returns the number of bytes written.
+    ///
+    /// This function operates on a "best effort basis"; in keeping with the
+    /// convention of `Write::write`, it makes at most one attempt to write
+    /// new data to the underlying writer. If that write only reports a partial
+    /// success, the remaining data will be buffered.
+    ///
+    /// Because this function attempts to send completed lines to the underlying
+    /// writer, it will also flush the existing buffer if it ends with a
+    /// newline, even if the incoming data does not contain any newlines.
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        let newline_idx = match memchr::memrchr(b'\n', buf) {
+            // If there are no new newlines (that is, if this write is less than
+            // one line), just do a regular buffered write (which may flush if
+            // we exceed the inner buffer's size)
+            None => {
+                self.flush_if_completed_line()?;
+                return self.buffer.write(buf);
+            }
+            // Otherwise, arrange for the lines to be written directly to the
+            // inner writer.
+            Some(newline_idx) => newline_idx + 1,
+        };
+
+        // Flush existing content to prepare for our write. We have to do this
+        // before attempting to write `buf` in order to maintain consistency;
+        // if we add `buf` to the buffer then try to flush it all at once,
+        // we're obligated to return Ok(), which would mean suppressing any
+        // errors that occur during flush.
+        self.buffer.flush_buf()?;
+
+        // This is what we're going to try to write directly to the inner
+        // writer. The rest will be buffered, if nothing goes wrong.
+        let lines = &buf[..newline_idx];
+
+        // Write `lines` directly to the inner writer. In keeping with the
+        // `write` convention, make at most one attempt to add new (unbuffered)
+        // data. Because this write doesn't touch the BufWriter state directly,
+        // and the buffer is known to be empty, we don't need to worry about
+        // self.buffer.panicked here.
+        let flushed = self.inner_mut().write(lines)?;
+
+        // If buffer returns Ok(0), propagate that to the caller without
+        // doing additional buffering; otherwise we're just guaranteeing
+        // an "ErrorKind::WriteZero" later.
+        if flushed == 0 {
+            return Ok(0);
+        }
+
+        // Now that the write has succeeded, buffer the rest (or as much of
+        // the rest as possible). If there were any unwritten newlines, we
+        // only buffer out to the last unwritten newline that fits in the
+        // buffer; this helps prevent flushing partial lines on subsequent
+        // calls to LineWriterShim::write.
+
+        // Handle the cases in order of most-common to least-common, under
+        // the presumption that most writes succeed in totality, and that most
+        // writes are smaller than the buffer.
+        // - Is this a partial line (ie, no newlines left in the unwritten tail)
+        // - If not, does the data out to the last unwritten newline fit in
+        //   the buffer?
+        // - If not, scan for the last newline that *does* fit in the buffer
+        let tail = if flushed >= newline_idx {
+            let tail = &buf[flushed..];
+            // Avoid unnecessary short writes by not splitting the remaining
+            // bytes if they're larger than the buffer.
+            // They can be written in full by the next call to write.
+            if tail.len() >= self.buffer.capacity() {
+                return Ok(flushed);
+            }
+            tail
+        } else if newline_idx - flushed <= self.buffer.capacity() {
+            &buf[flushed..newline_idx]
+        } else {
+            let scan_area = &buf[flushed..];
+            let scan_area = &scan_area[..self.buffer.capacity()];
+            match memchr::memrchr(b'\n', scan_area) {
+                Some(newline_idx) => &scan_area[..newline_idx + 1],
+                None => scan_area,
+            }
+        };
+
+        let buffered = self.buffer.write_to_buf(tail);
+        Ok(flushed + buffered)
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        self.buffer.flush()
+    }
+
+    /// Writes some vectored data into this BufWriter with line buffering.
+    ///
+    /// This means that, if any newlines are present in the data, the data up to
+    /// and including the buffer containing the last newline is sent directly to
+    /// the inner writer, and the data after it is buffered. Returns the number
+    /// of bytes written.
+    ///
+    /// This function operates on a "best effort basis"; in keeping with the
+    /// convention of `Write::write`, it makes at most one attempt to write
+    /// new data to the underlying writer.
+    ///
+    /// Because this function attempts to send completed lines to the underlying
+    /// writer, it will also flush the existing buffer if it contains any
+    /// newlines.
+    ///
+    /// Because sorting through an array of `IoSlice` can be a bit convoluted,
+    /// This method differs from write in the following ways:
+    ///
+    /// - It attempts to write the full content of all the buffers up to and
+    ///   including the one containing the last newline. This means that it
+    ///   may attempt to write a partial line, that buffer has data past the
+    ///   newline.
+    /// - If the write only reports partial success, it does not attempt to
+    ///   find the precise location of the written bytes and buffer the rest.
+    ///
+    /// If the underlying vector doesn't support vectored writing, we instead
+    /// simply write the first non-empty buffer with `write`. This way, we
+    /// get the benefits of more granular partial-line handling without losing
+    /// anything in efficiency
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        // If there's no specialized behavior for write_vectored, just use
+        // write. This has the benefit of more granular partial-line handling.
+        if !self.is_write_vectored() {
+            return match bufs.iter().find(|buf| !buf.is_empty()) {
+                Some(buf) => self.write(buf),
+                None => Ok(0),
+            };
+        }
+
+        // Find the buffer containing the last newline
+        // FIXME: This is overly slow if there are very many bufs and none contain
+        // newlines. e.g. writev() on Linux only writes up to 1024 slices, so
+        // scanning the rest is wasted effort. This makes write_all_vectored()
+        // quadratic.
+        let last_newline_buf_idx = bufs
+            .iter()
+            .enumerate()
+            .rev()
+            .find_map(|(i, buf)| memchr::memchr(b'\n', buf).map(|_| i));
+
+        // If there are no new newlines (that is, if this write is less than
+        // one line), just do a regular buffered write
+        let last_newline_buf_idx = match last_newline_buf_idx {
+            // No newlines; just do a normal buffered write
+            None => {
+                self.flush_if_completed_line()?;
+                return self.buffer.write_vectored(bufs);
+            }
+            Some(i) => i,
+        };
+
+        // Flush existing content to prepare for our write
+        self.buffer.flush_buf()?;
+
+        // This is what we're going to try to write directly to the inner
+        // writer. The rest will be buffered, if nothing goes wrong.
+        let (lines, tail) = bufs.split_at(last_newline_buf_idx + 1);
+
+        // Write `lines` directly to the inner writer. In keeping with the
+        // `write` convention, make at most one attempt to add new (unbuffered)
+        // data. Because this write doesn't touch the BufWriter state directly,
+        // and the buffer is known to be empty, we don't need to worry about
+        // self.panicked here.
+        let flushed = self.inner_mut().write_vectored(lines)?;
+
+        // If inner returns Ok(0), propagate that to the caller without
+        // doing additional buffering; otherwise we're just guaranteeing
+        // an "ErrorKind::WriteZero" later.
+        if flushed == 0 {
+            return Ok(0);
+        }
+
+        // Don't try to reconstruct the exact amount written; just bail
+        // in the event of a partial write
+        let mut lines_len: usize = 0;
+        for buf in lines {
+            // With overlapping/duplicate slices the total length may in theory
+            // exceed usize::MAX
+            lines_len = lines_len.saturating_add(buf.len());
+            if flushed < lines_len {
+                return Ok(flushed);
+            }
+        }
+
+        // Now that the write has succeeded, buffer the rest (or as much of the
+        // rest as possible)
+        let buffered: usize = tail
+            .iter()
+            .filter(|buf| !buf.is_empty())
+            .map(|buf| self.buffer.write_to_buf(buf))
+            .take_while(|&n| n > 0)
+            .sum();
+
+        Ok(flushed + buffered)
+    }
+
+    fn is_write_vectored(&self) -> bool {
+        self.inner().is_write_vectored()
+    }
+
+    /// Writes some data into this BufWriter with line buffering.
+    ///
+    /// This means that, if any newlines are present in the data, the data up to
+    /// the last newline is sent directly to the underlying writer, and data
+    /// after it is buffered.
+    ///
+    /// Because this function attempts to send completed lines to the underlying
+    /// writer, it will also flush the existing buffer if it contains any
+    /// newlines, even if the incoming data does not contain any newlines.
+    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
+        match memchr::memrchr(b'\n', buf) {
+            // If there are no new newlines (that is, if this write is less than
+            // one line), just do a regular buffered write (which may flush if
+            // we exceed the inner buffer's size)
+            None => {
+                self.flush_if_completed_line()?;
+                self.buffer.write_all(buf)
+            }
+            Some(newline_idx) => {
+                let (lines, tail) = buf.split_at(newline_idx + 1);
+
+                if self.buffered().is_empty() {
+                    self.inner_mut().write_all(lines)?;
+                } else {
+                    // If there is any buffered data, we add the incoming lines
+                    // to that buffer before flushing, which saves us at least
+                    // one write call. We can't really do this with `write`,
+                    // since we can't do this *and* not suppress errors *and*
+                    // report a consistent state to the caller in a return
+                    // value, but here in write_all it's fine.
+                    self.buffer.write_all(lines)?;
+                    self.buffer.flush_buf()?;
+                }
+
+                self.buffer.write_all(tail)
+            }
+        }
+    }
+}

crates/io/src/io/buffered/mod.rs

@@ -0,0 +1,187 @@
+//! Buffering wrappers for I/O traits
+
+mod bufreader;
+mod bufwriter;
+mod linewriter;
+mod linewritershim;
+
+
+#[stable(feature = "bufwriter_into_parts", since = "1.56.0")]
+pub use bufwriter::WriterPanicked;
+use linewritershim::LineWriterShim;
+
+#[stable(feature = "rust1", since = "1.0.0")]
+pub use self::{bufreader::BufReader, bufwriter::BufWriter, linewriter::LineWriter};
+use crate::io::Error;
+use crate::{error, fmt};
+
+/// An error returned by [`BufWriter::into_inner`] which combines an error that
+/// happened while writing out the buffer, and the buffered writer object
+/// which may be used to recover from the condition.
+///
+/// # Examples
+///
+/// ```no_run
+/// use std::io::BufWriter;
+/// use std::net::TcpStream;
+///
+/// let mut stream = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
+///
+/// // do stuff with the stream
+///
+/// // we want to get our `TcpStream` back, so let's try:
+///
+/// let stream = match stream.into_inner() {
+///     Ok(s) => s,
+///     Err(e) => {
+///         // Here, e is an IntoInnerError
+///         panic!("An error occurred");
+///     }
+/// };
+/// ```
+#[derive(Debug)]
+#[stable(feature = "rust1", since = "1.0.0")]
+pub struct IntoInnerError<W>(W, Error);
+
+impl<W> IntoInnerError<W> {
+    /// Constructs a new IntoInnerError
+    fn new(writer: W, error: Error) -> Self {
+        Self(writer, error)
+    }
+
+    /// Helper to construct a new IntoInnerError; intended to help with
+    /// adapters that wrap other adapters
+    fn new_wrapped<W2>(self, f: impl FnOnce(W) -> W2) -> IntoInnerError<W2> {
+        let Self(writer, error) = self;
+        IntoInnerError::new(f(writer), error)
+    }
+
+    /// Returns the error which caused the call to [`BufWriter::into_inner()`]
+    /// to fail.
+    ///
+    /// This error was returned when attempting to write the internal buffer.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use std::io::BufWriter;
+    /// use std::net::TcpStream;
+    ///
+    /// let mut stream = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
+    ///
+    /// // do stuff with the stream
+    ///
+    /// // we want to get our `TcpStream` back, so let's try:
+    ///
+    /// let stream = match stream.into_inner() {
+    ///     Ok(s) => s,
+    ///     Err(e) => {
+    ///         // Here, e is an IntoInnerError, let's log the inner error.
+    ///         //
+    ///         // We'll just 'log' to stdout for this example.
+    ///         println!("{}", e.error());
+    ///
+    ///         panic!("An unexpected error occurred.");
+    ///     }
+    /// };
+    /// ```
+    #[stable(feature = "rust1", since = "1.0.0")]
+    pub fn error(&self) -> &Error {
+        &self.1
+    }
+
+    /// Returns the buffered writer instance which generated the error.
+    ///
+    /// The returned object can be used for error recovery, such as
+    /// re-inspecting the buffer.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use std::io::BufWriter;
+    /// use std::net::TcpStream;
+    ///
+    /// let mut stream = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
+    ///
+    /// // do stuff with the stream
+    ///
+    /// // we want to get our `TcpStream` back, so let's try:
+    ///
+    /// let stream = match stream.into_inner() {
+    ///     Ok(s) => s,
+    ///     Err(e) => {
+    ///         // Here, e is an IntoInnerError, let's re-examine the buffer:
+    ///         let buffer = e.into_inner();
+    ///
+    ///         // do stuff to try to recover
+    ///
+    ///         // afterwards, let's just return the stream
+    ///         buffer.into_inner().unwrap()
+    ///     }
+    /// };
+    /// ```
+    #[stable(feature = "rust1", since = "1.0.0")]
+    pub fn into_inner(self) -> W {
+        self.0
+    }
+
+    /// Consumes the [`IntoInnerError`] and returns the error which caused the call to
+    /// [`BufWriter::into_inner()`] to fail.  Unlike `error`, this can be used to
+    /// obtain ownership of the underlying error.
+    ///
+    /// # Example
+    /// ```
+    /// use std::io::{BufWriter, ErrorKind, Write};
+    ///
+    /// let mut not_enough_space = [0u8; 10];
+    /// let mut stream = BufWriter::new(not_enough_space.as_mut());
+    /// write!(stream, "this cannot be actually written").unwrap();
+    /// let into_inner_err = stream.into_inner().expect_err("now we discover it's too small");
+    /// let err = into_inner_err.into_error();
+    /// assert_eq!(err.kind(), ErrorKind::WriteZero);
+    /// ```
+    #[stable(feature = "io_into_inner_error_parts", since = "1.55.0")]
+    pub fn into_error(self) -> Error {
+        self.1
+    }
+
+    /// Consumes the [`IntoInnerError`] and returns the error which caused the call to
+    /// [`BufWriter::into_inner()`] to fail, and the underlying writer.
+    ///
+    /// This can be used to simply obtain ownership of the underlying error; it can also be used for
+    /// advanced error recovery.
+    ///
+    /// # Example
+    /// ```
+    /// use std::io::{BufWriter, ErrorKind, Write};
+    ///
+    /// let mut not_enough_space = [0u8; 10];
+    /// let mut stream = BufWriter::new(not_enough_space.as_mut());
+    /// write!(stream, "this cannot be actually written").unwrap();
+    /// let into_inner_err = stream.into_inner().expect_err("now we discover it's too small");
+    /// let (err, recovered_writer) = into_inner_err.into_parts();
+    /// assert_eq!(err.kind(), ErrorKind::WriteZero);
+    /// assert_eq!(recovered_writer.buffer(), b"t be actually written");
+    /// ```
+    #[stable(feature = "io_into_inner_error_parts", since = "1.55.0")]
+    pub fn into_parts(self) -> (Error, W) {
+        (self.1, self.0)
+    }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<W> From<IntoInnerError<W>> for Error {
+    fn from(iie: IntoInnerError<W>) -> Error {
+        iie.1
+    }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<W: Send + fmt::Debug> error::Error for IntoInnerError<W> {}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<W> fmt::Display for IntoInnerError<W> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.error().fmt(f)
+    }
+}

crates/io/src/io/copy.rs

@@ -0,0 +1,295 @@
+use super::{BorrowedBuf, BufReader, BufWriter, DEFAULT_BUF_SIZE, Read, Result, Write};
+use crate::alloc::Allocator;
+use crate::cmp;
+use crate::collections::VecDeque;
+use crate::io::IoSlice;
+use crate::mem::MaybeUninit;
+use crate::sys::io::{CopyState, kernel_copy};
+
+
+/// Copies the entire contents of a reader into a writer.
+///
+/// This function will continuously read data from `reader` and then
+/// write it into `writer` in a streaming fashion until `reader`
+/// returns EOF.
+///
+/// On success, the total number of bytes that were copied from
+/// `reader` to `writer` is returned.
+///
+/// If you want to copy the contents of one file to another and you’re
+/// working with filesystem paths, see the [`fs::copy`] function.
+///
+/// [`fs::copy`]: crate::fs::copy
+///
+/// # Errors
+///
+/// This function will return an error immediately if any call to [`read`] or
+/// [`write`] returns an error. All instances of [`ErrorKind::Interrupted`] are
+/// handled by this function and the underlying operation is retried.
+///
+/// [`read`]: Read::read
+/// [`write`]: Write::write
+/// [`ErrorKind::Interrupted`]: crate::io::ErrorKind::Interrupted
+///
+/// # Examples
+///
+/// ```
+/// use std::io;
+///
+/// fn main() -> io::Result<()> {
+///     let mut reader: &[u8] = b"hello";
+///     let mut writer: Vec<u8> = vec![];
+///
+///     io::copy(&mut reader, &mut writer)?;
+///
+///     assert_eq!(&b"hello"[..], &writer[..]);
+///     Ok(())
+/// }
+/// ```
+///
+/// # Platform-specific behavior
+///
+/// On Linux (including Android), this function uses `copy_file_range(2)`,
+/// `sendfile(2)` or `splice(2)` syscalls to move data directly between file
+/// descriptors if possible.
+///
+/// Note that platform-specific behavior [may change in the future][changes].
+///
+/// [changes]: crate::io#platform-specific-behavior
+#[stable(feature = "rust1", since = "1.0.0")]
+pub fn copy<R: ?Sized, W: ?Sized>(reader: &mut R, writer: &mut W) -> Result<u64>
+where
+    R: Read,
+    W: Write,
+{
+    match kernel_copy(reader, writer)? {
+        CopyState::Ended(copied) => Ok(copied),
+        CopyState::Fallback(copied) => {
+            generic_copy(reader, writer).map(|additional| copied + additional)
+        }
+    }
+}
+
+/// The userspace read-write-loop implementation of `io::copy` that is used when
+/// OS-specific specializations for copy offloading are not available or not applicable.
+fn generic_copy<R: ?Sized, W: ?Sized>(reader: &mut R, writer: &mut W) -> Result<u64>
+where
+    R: Read,
+    W: Write,
+{
+    let read_buf = BufferedReaderSpec::buffer_size(reader);
+    let write_buf = BufferedWriterSpec::buffer_size(writer);
+
+    if read_buf >= DEFAULT_BUF_SIZE && read_buf >= write_buf {
+        return BufferedReaderSpec::copy_to(reader, writer);
+    }
+
+    BufferedWriterSpec::copy_from(writer, reader)
+}
+
+/// Specialization of the read-write loop that reuses the internal
+/// buffer of a BufReader. If there's no buffer then the writer side
+/// should be used instead.
+trait BufferedReaderSpec {
+    fn buffer_size(&self) -> usize;
+
+    fn copy_to(&mut self, to: &mut (impl Write + ?Sized)) -> Result<u64>;
+}
+
+impl<T> BufferedReaderSpec for T
+where
+    Self: Read,
+    T: ?Sized,
+{
+    #[inline]
+    default fn buffer_size(&self) -> usize {
+        0
+    }
+
+    default fn copy_to(&mut self, _to: &mut (impl Write + ?Sized)) -> Result<u64> {
+        unreachable!("only called from specializations")
+    }
+}
+
+impl BufferedReaderSpec for &[u8] {
+    fn buffer_size(&self) -> usize {
+        // prefer this specialization since the source "buffer" is all we'll ever need,
+        // even if it's small
+        usize::MAX
+    }
+
+    fn copy_to(&mut self, to: &mut (impl Write + ?Sized)) -> Result<u64> {
+        let len = self.len();
+        to.write_all(self)?;
+        *self = &self[len..];
+        Ok(len as u64)
+    }
+}
+
+impl<A: Allocator> BufferedReaderSpec for VecDeque<u8, A> {
+    fn buffer_size(&self) -> usize {
+        // prefer this specialization since the source "buffer" is all we'll ever need,
+        // even if it's small
+        usize::MAX
+    }
+
+    fn copy_to(&mut self, to: &mut (impl Write + ?Sized)) -> Result<u64> {
+        let len = self.len();
+        let (front, back) = self.as_slices();
+        let bufs = &mut [IoSlice::new(front), IoSlice::new(back)];
+        to.write_all_vectored(bufs)?;
+        self.clear();
+        Ok(len as u64)
+    }
+}
+
+impl<I> BufferedReaderSpec for BufReader<I>
+where
+    Self: Read,
+    I: ?Sized,
+{
+    fn buffer_size(&self) -> usize {
+        self.capacity()
+    }
+
+    fn copy_to(&mut self, to: &mut (impl Write + ?Sized)) -> Result<u64> {
+        let mut len = 0;
+
+        loop {
+            // Hack: this relies on `impl Read for BufReader` always calling fill_buf
+            // if the buffer is empty, even for empty slices.
+            // It can't be called directly here since specialization prevents us
+            // from adding I: Read
+            match self.read(&mut []) {
+                Ok(_) => {}
+                Err(e) if e.is_interrupted() => continue,
+                Err(e) => return Err(e),
+            }
+            let buf = self.buffer();
+            if self.buffer().len() == 0 {
+                return Ok(len);
+            }
+
+            // In case the writer side is a BufWriter then its write_all
+            // implements an optimization that passes through large
+            // buffers to the underlying writer. That code path is #[cold]
+            // but we're still avoiding redundant memcopies when doing
+            // a copy between buffered inputs and outputs.
+            to.write_all(buf)?;
+            len += buf.len() as u64;
+            self.discard_buffer();
+        }
+    }
+}
+
+/// Specialization of the read-write loop that either uses a stack buffer
+/// or reuses the internal buffer of a BufWriter
+trait BufferedWriterSpec: Write {
+    fn buffer_size(&self) -> usize;
+
+    fn copy_from<R: Read + ?Sized>(&mut self, reader: &mut R) -> Result<u64>;
+}
+
+impl<W: Write + ?Sized> BufferedWriterSpec for W {
+    #[inline]
+    default fn buffer_size(&self) -> usize {
+        0
+    }
+
+    default fn copy_from<R: Read + ?Sized>(&mut self, reader: &mut R) -> Result<u64> {
+        stack_buffer_copy(reader, self)
+    }
+}
+
+impl<I: Write + ?Sized> BufferedWriterSpec for BufWriter<I> {
+    fn buffer_size(&self) -> usize {
+        self.capacity()
+    }
+
+    fn copy_from<R: Read + ?Sized>(&mut self, reader: &mut R) -> Result<u64> {
+        if self.capacity() < DEFAULT_BUF_SIZE {
+            return stack_buffer_copy(reader, self);
+        }
+
+        let mut len = 0;
+        let mut init = 0;
+
+        loop {
+            let buf = self.buffer_mut();
+            let mut read_buf: BorrowedBuf<'_> = buf.spare_capacity_mut().into();
+
+            unsafe {
+                // SAFETY: init is either 0 or the init_len from the previous iteration.
+                read_buf.set_init(init);
+            }
+
+            if read_buf.capacity() >= DEFAULT_BUF_SIZE {
+                let mut cursor = read_buf.unfilled();
+                match reader.read_buf(cursor.reborrow()) {
+                    Ok(()) => {
+                        let bytes_read = cursor.written();
+
+                        if bytes_read == 0 {
+                            return Ok(len);
+                        }
+
+                        init = read_buf.init_len() - bytes_read;
+                        len += bytes_read as u64;
+
+                        // SAFETY: BorrowedBuf guarantees all of its filled bytes are init
+                        unsafe { buf.set_len(buf.len() + bytes_read) };
+
+                        // Read again if the buffer still has enough capacity, as BufWriter itself would do
+                        // This will occur if the reader returns short reads
+                    }
+                    Err(ref e) if e.is_interrupted() => {}
+                    Err(e) => return Err(e),
+                }
+            } else {
+                // All the bytes that were already in the buffer are initialized,
+                // treat them as such when the buffer is flushed.
+                init += buf.len();
+
+                self.flush_buf()?;
+            }
+        }
+    }
+}
+
+impl BufferedWriterSpec for Vec<u8> {
+    fn buffer_size(&self) -> usize {
+        cmp::max(DEFAULT_BUF_SIZE, self.capacity() - self.len())
+    }
+
+    fn copy_from<R: Read + ?Sized>(&mut self, reader: &mut R) -> Result<u64> {
+        reader.read_to_end(self).map(|bytes| u64::try_from(bytes).expect("usize overflowed u64"))
+    }
+}
+
+fn stack_buffer_copy<R: Read + ?Sized, W: Write + ?Sized>(
+    reader: &mut R,
+    writer: &mut W,
+) -> Result<u64> {
+    let buf: &mut [_] = &mut [MaybeUninit::uninit(); DEFAULT_BUF_SIZE];
+    let mut buf: BorrowedBuf<'_> = buf.into();
+
+    let mut len = 0;
+
+    loop {
+        match reader.read_buf(buf.unfilled()) {
+            Ok(()) => {}
+            Err(e) if e.is_interrupted() => continue,
+            Err(e) => return Err(e),
+        };
+
+        if buf.filled().is_empty() {
+            break;
+        }
+
+        len += buf.filled().len() as u64;
+        writer.write_all(buf.filled())?;
+        buf.clear();
+    }
+
+    Ok(len)
+}

crates/io/src/io/cursor.rs

@@ -0,0 +1,755 @@
+
+use crate::alloc::Allocator;
+use crate::cmp;
+use crate::io::prelude::*;
+use crate::io::{self, BorrowedCursor, ErrorKind, IoSlice, IoSliceMut, SeekFrom};
+
+/// A `Cursor` wraps an in-memory buffer and provides it with a
+/// [`Seek`] implementation.
+///
+/// `Cursor`s are used with in-memory buffers, anything implementing
+/// <code>[AsRef]<\[u8]></code>, to allow them to implement [`Read`] and/or [`Write`],
+/// allowing these buffers to be used anywhere you might use a reader or writer
+/// that does actual I/O.
+///
+/// The standard library implements some I/O traits on various types which
+/// are commonly used as a buffer, like <code>Cursor<[Vec]\<u8>></code> and
+/// <code>Cursor<[&\[u8\]][bytes]></code>.
+///
+/// # Examples
+///
+/// We may want to write bytes to a [`File`] in our production
+/// code, but use an in-memory buffer in our tests. We can do this with
+/// `Cursor`:
+///
+/// [bytes]: crate::slice "slice"
+/// [`File`]: crate::fs::File
+///
+/// ```no_run
+/// use std::io::prelude::*;
+/// use std::io::{self, SeekFrom};
+/// use std::fs::File;
+///
+/// // a library function we've written
+/// fn write_ten_bytes_at_end<W: Write + Seek>(mut writer: W) -> io::Result<()> {
+///     writer.seek(SeekFrom::End(-10))?;
+///
+///     for i in 0..10 {
+///         writer.write(&[i])?;
+///     }
+///
+///     // all went well
+///     Ok(())
+/// }
+///
+/// # fn foo() -> io::Result<()> {
+/// // Here's some code that uses this library function.
+/// //
+/// // We might want to use a BufReader here for efficiency, but let's
+/// // keep this example focused.
+/// let mut file = File::create("foo.txt")?;
+/// // First, we need to allocate 10 bytes to be able to write into.
+/// file.set_len(10)?;
+///
+/// write_ten_bytes_at_end(&mut file)?;
+/// # Ok(())
+/// # }
+///
+/// // now let's write a test
+/// #[test]
+/// fn test_writes_bytes() {
+///     // setting up a real File is much slower than an in-memory buffer,
+///     // let's use a cursor instead
+///     use std::io::Cursor;
+///     let mut buff = Cursor::new(vec![0; 15]);
+///
+///     write_ten_bytes_at_end(&mut buff).unwrap();
+///
+///     assert_eq!(&buff.get_ref()[5..15], &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
+/// }
+/// ```
+#[stable(feature = "rust1", since = "1.0.0")]
+#[derive(Debug, Default, Eq, PartialEq)]
+pub struct Cursor<T> {
+    inner: T,
+    pos: u64,
+}
+
+impl<T> Cursor<T> {
+    /// Creates a new cursor wrapping the provided underlying in-memory buffer.
+    ///
+    /// Cursor initial position is `0` even if underlying buffer (e.g., [`Vec`])
+    /// is not empty. So writing to cursor starts with overwriting [`Vec`]
+    /// content, not with appending to it.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::io::Cursor;
+    ///
+    /// let buff = Cursor::new(Vec::new());
+    /// # fn force_inference(_: &Cursor<Vec<u8>>) {}
+    /// # force_inference(&buff);
+    /// ```
+    #[stable(feature = "rust1", since = "1.0.0")]
+    #[rustc_const_stable(feature = "const_io_structs", since = "1.79.0")]
+    pub const fn new(inner: T) -> Cursor<T> {
+        Cursor { pos: 0, inner }
+    }
+
+    /// Consumes this cursor, returning the underlying value.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::io::Cursor;
+    ///
+    /// let buff = Cursor::new(Vec::new());
+    /// # fn force_inference(_: &Cursor<Vec<u8>>) {}
+    /// # force_inference(&buff);
+    ///
+    /// let vec = buff.into_inner();
+    /// ```
+    #[stable(feature = "rust1", since = "1.0.0")]
+    pub fn into_inner(self) -> T {
+        self.inner
+    }
+
+    /// Gets a reference to the underlying value in this cursor.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::io::Cursor;
+    ///
+    /// let buff = Cursor::new(Vec::new());
+    /// # fn force_inference(_: &Cursor<Vec<u8>>) {}
+    /// # force_inference(&buff);
+    ///
+    /// let reference = buff.get_ref();
+    /// ```
+    #[stable(feature = "rust1", since = "1.0.0")]
+    #[rustc_const_stable(feature = "const_io_structs", since = "1.79.0")]
+    pub const fn get_ref(&self) -> &T {
+        &self.inner
+    }
+
+    /// Gets a mutable reference to the underlying value in this cursor.
+    ///
+    /// Care should be taken to avoid modifying the internal I/O state of the
+    /// underlying value as it may corrupt this cursor's position.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::io::Cursor;
+    ///
+    /// let mut buff = Cursor::new(Vec::new());
+    /// # fn force_inference(_: &Cursor<Vec<u8>>) {}
+    /// # force_inference(&buff);
+    ///
+    /// let reference = buff.get_mut();
+    /// ```
+    #[stable(feature = "rust1", since = "1.0.0")]
+    #[rustc_const_stable(feature = "const_mut_cursor", since = "1.86.0")]
+    pub const fn get_mut(&mut self) -> &mut T {
+        &mut self.inner
+    }
+
+    /// Returns the current position of this cursor.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::io::Cursor;
+    /// use std::io::prelude::*;
+    /// use std::io::SeekFrom;
+    ///
+    /// let mut buff = Cursor::new(vec![1, 2, 3, 4, 5]);
+    ///
+    /// assert_eq!(buff.position(), 0);
+    ///
+    /// buff.seek(SeekFrom::Current(2)).unwrap();
+    /// assert_eq!(buff.position(), 2);
+    ///
+    /// buff.seek(SeekFrom::Current(-1)).unwrap();
+    /// assert_eq!(buff.position(), 1);
+    /// ```
+    #[stable(feature = "rust1", since = "1.0.0")]
+    #[rustc_const_stable(feature = "const_io_structs", since = "1.79.0")]
+    pub const fn position(&self) -> u64 {
+        self.pos
+    }
+
+    /// Sets the position of this cursor.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::io::Cursor;
+    ///
+    /// let mut buff = Cursor::new(vec![1, 2, 3, 4, 5]);
+    ///
+    /// assert_eq!(buff.position(), 0);
+    ///
+    /// buff.set_position(2);
+    /// assert_eq!(buff.position(), 2);
+    ///
+    /// buff.set_position(4);
+    /// assert_eq!(buff.position(), 4);
+    /// ```
+    #[stable(feature = "rust1", since = "1.0.0")]
+    #[rustc_const_stable(feature = "const_mut_cursor", since = "1.86.0")]
+    pub const fn set_position(&mut self, pos: u64) {
+        self.pos = pos;
+    }
+}
+
+impl<T> Cursor<T>
+where
+    T: AsRef<[u8]>,
+{
+    /// Splits the underlying slice at the cursor position and returns them.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(cursor_split)]
+    /// use std::io::Cursor;
+    ///
+    /// let mut buff = Cursor::new(vec![1, 2, 3, 4, 5]);
+    ///
+    /// assert_eq!(buff.split(), ([].as_slice(), [1, 2, 3, 4, 5].as_slice()));
+    ///
+    /// buff.set_position(2);
+    /// assert_eq!(buff.split(), ([1, 2].as_slice(), [3, 4, 5].as_slice()));
+    ///
+    /// buff.set_position(6);
+    /// assert_eq!(buff.split(), ([1, 2, 3, 4, 5].as_slice(), [].as_slice()));
+    /// ```
+    #[unstable(feature = "cursor_split", issue = "86369")]
+    pub fn split(&self) -> (&[u8], &[u8]) {
+        let slice = self.inner.as_ref();
+        let pos = self.pos.min(slice.len() as u64);
+        slice.split_at(pos as usize)
+    }
+}
+
+impl<T> Cursor<T>
+where
+    T: AsMut<[u8]>,
+{
+    /// Splits the underlying slice at the cursor position and returns them
+    /// mutably.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(cursor_split)]
+    /// use std::io::Cursor;
+    ///
+    /// let mut buff = Cursor::new(vec![1, 2, 3, 4, 5]);
+    ///
+    /// assert_eq!(buff.split_mut(), ([].as_mut_slice(), [1, 2, 3, 4, 5].as_mut_slice()));
+    ///
+    /// buff.set_position(2);
+    /// assert_eq!(buff.split_mut(), ([1, 2].as_mut_slice(), [3, 4, 5].as_mut_slice()));
+    ///
+    /// buff.set_position(6);
+    /// assert_eq!(buff.split_mut(), ([1, 2, 3, 4, 5].as_mut_slice(), [].as_mut_slice()));
+    /// ```
+    #[unstable(feature = "cursor_split", issue = "86369")]
+    pub fn split_mut(&mut self) -> (&mut [u8], &mut [u8]) {
+        let slice = self.inner.as_mut();
+        let pos = self.pos.min(slice.len() as u64);
+        slice.split_at_mut(pos as usize)
+    }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<T> Clone for Cursor<T>
+where
+    T: Clone,
+{
+    #[inline]
+    fn clone(&self) -> Self {
+        Cursor { inner: self.inner.clone(), pos: self.pos }
+    }
+
+    #[inline]
+    fn clone_from(&mut self, other: &Self) {
+        self.inner.clone_from(&other.inner);
+        self.pos = other.pos;
+    }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<T> io::Seek for Cursor<T>
+where
+    T: AsRef<[u8]>,
+{
+    fn seek(&mut self, style: SeekFrom) -> io::Result<u64> {
+        let (base_pos, offset) = match style {
+            SeekFrom::Start(n) => {
+                self.pos = n;
+                return Ok(n);
+            }
+            SeekFrom::End(n) => (self.inner.as_ref().len() as u64, n),
+            SeekFrom::Current(n) => (self.pos, n),
+        };
+        match base_pos.checked_add_signed(offset) {
+            Some(n) => {
+                self.pos = n;
+                Ok(self.pos)
+            }
+            None => Err(io::const_error!(
+                ErrorKind::InvalidInput,
+                "invalid seek to a negative or overflowing position",
+            )),
+        }
+    }
+
+    fn stream_len(&mut self) -> io::Result<u64> {
+        Ok(self.inner.as_ref().len() as u64)
+    }
+
+    fn stream_position(&mut self) -> io::Result<u64> {
+        Ok(self.pos)
+    }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<T> Read for Cursor<T>
+where
+    T: AsRef<[u8]>,
+{
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        let n = Read::read(&mut Cursor::split(self).1, buf)?;
+        self.pos += n as u64;
+        Ok(n)
+    }
+
+    fn read_buf(&mut self, mut cursor: BorrowedCursor<'_>) -> io::Result<()> {
+        let prev_written = cursor.written();
+
+        Read::read_buf(&mut Cursor::split(self).1, cursor.reborrow())?;
+
+        self.pos += (cursor.written() - prev_written) as u64;
+
+        Ok(())
+    }
+
+    fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
+        let mut nread = 0;
+        for buf in bufs {
+            let n = self.read(buf)?;
+            nread += n;
+            if n < buf.len() {
+                break;
+            }
+        }
+        Ok(nread)
+    }
+
+    fn is_read_vectored(&self) -> bool {
+        true
+    }
+
+    fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
+        let result = Read::read_exact(&mut Cursor::split(self).1, buf);
+
+        match result {
+            Ok(_) => self.pos += buf.len() as u64,
+            // The only possible error condition is EOF, so place the cursor at "EOF"
+            Err(_) => self.pos = self.inner.as_ref().len() as u64,
+        }
+
+        result
+    }
+
+    fn read_buf_exact(&mut self, mut cursor: BorrowedCursor<'_>) -> io::Result<()> {
+        let prev_written = cursor.written();
+
+        let result = Read::read_buf_exact(&mut Cursor::split(self).1, cursor.reborrow());
+        self.pos += (cursor.written() - prev_written) as u64;
+
+        result
+    }
+
+    fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
+        let content = Cursor::split(self).1;
+        let len = content.len();
+        buf.try_reserve(len)?;
+        buf.extend_from_slice(content);
+        self.pos += len as u64;
+
+        Ok(len)
+    }
+
+    fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> {
+        let content =
+            crate::str::from_utf8(Cursor::split(self).1).map_err(|_| io::Error::INVALID_UTF8)?;
+        let len = content.len();
+        buf.try_reserve(len)?;
+        buf.push_str(content);
+        self.pos += len as u64;
+
+        Ok(len)
+    }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<T> BufRead for Cursor<T>
+where
+    T: AsRef<[u8]>,
+{
+    fn fill_buf(&mut self) -> io::Result<&[u8]> {
+        Ok(Cursor::split(self).1)
+    }
+    fn consume(&mut self, amt: usize) {
+        self.pos += amt as u64;
+    }
+}
+
+// Non-resizing write implementation
+#[inline]
+fn slice_write(pos_mut: &mut u64, slice: &mut [u8], buf: &[u8]) -> io::Result<usize> {
+    let pos = cmp::min(*pos_mut, slice.len() as u64);
+    let amt = (&mut slice[(pos as usize)..]).write(buf)?;
+    *pos_mut += amt as u64;
+    Ok(amt)
+}
+
+#[inline]
+fn slice_write_vectored(
+    pos_mut: &mut u64,
+    slice: &mut [u8],
+    bufs: &[IoSlice<'_>],
+) -> io::Result<usize> {
+    let mut nwritten = 0;
+    for buf in bufs {
+        let n = slice_write(pos_mut, slice, buf)?;
+        nwritten += n;
+        if n < buf.len() {
+            break;
+        }
+    }
+    Ok(nwritten)
+}
+
+#[inline]
+fn slice_write_all(pos_mut: &mut u64, slice: &mut [u8], buf: &[u8]) -> io::Result<()> {
+    let n = slice_write(pos_mut, slice, buf)?;
+    if n < buf.len() { Err(io::Error::WRITE_ALL_EOF) } else { Ok(()) }
+}
+
+#[inline]
+fn slice_write_all_vectored(
+    pos_mut: &mut u64,
+    slice: &mut [u8],
+    bufs: &[IoSlice<'_>],
+) -> io::Result<()> {
+    for buf in bufs {
+        let n = slice_write(pos_mut, slice, buf)?;
+        if n < buf.len() {
+            return Err(io::Error::WRITE_ALL_EOF);
+        }
+    }
+    Ok(())
+}
+
+/// Reserves the required space, and pads the vec with 0s if necessary.
+fn reserve_and_pad<A: Allocator>(
+    pos_mut: &mut u64,
+    vec: &mut Vec<u8, A>,
+    buf_len: usize,
+) -> io::Result<usize> {
+    let pos: usize = (*pos_mut).try_into().map_err(|_| {
+        io::const_error!(
+            ErrorKind::InvalidInput,
+            "cursor position exceeds maximum possible vector length",
+        )
+    })?;
+
+    // For safety reasons, we don't want these numbers to overflow
+    // otherwise our allocation won't be enough
+    let desired_cap = pos.saturating_add(buf_len);
+    if desired_cap > vec.capacity() {
+        // We want our vec's total capacity
+        // to have room for (pos+buf_len) bytes. Reserve allocates
+        // based on additional elements from the length, so we need to
+        // reserve the difference
+        vec.reserve(desired_cap - vec.len());
+    }
+    // Pad if pos is above the current len.
+    if pos > vec.len() {
+        let diff = pos - vec.len();
+        // Unfortunately, `resize()` would suffice but the optimiser does not
+        // realise the `reserve` it does can be eliminated. So we do it manually
+        // to eliminate that extra branch
+        let spare = vec.spare_capacity_mut();
+        debug_assert!(spare.len() >= diff);
+        // Safety: we have allocated enough capacity for this.
+        // And we are only writing, not reading
+        unsafe {
+            spare.get_unchecked_mut(..diff).fill(core::mem::MaybeUninit::new(0));
+            vec.set_len(pos);
+        }
+    }
+
+    Ok(pos)
+}
+
+/// Writes the slice to the vec without allocating.
+///
+/// # Safety
+///
+/// `vec` must have `buf.len()` spare capacity.
+unsafe fn vec_write_all_unchecked<A>(pos: usize, vec: &mut Vec<u8, A>, buf: &[u8]) -> usize
+where
+    A: Allocator,
+{
+    debug_assert!(vec.capacity() >= pos + buf.len());
+    unsafe { vec.as_mut_ptr().add(pos).copy_from(buf.as_ptr(), buf.len()) };
+    pos + buf.len()
+}
+
+/// Resizing `write_all` implementation for [`Cursor`].
+///
+/// Cursor is allowed to have a pre-allocated and initialised
+/// vector body, but with a position of 0. This means the [`Write`]
+/// will overwrite the contents of the vec.
+///
+/// This also allows for the vec body to be empty, but with a position of N.
+/// This means that [`Write`] will pad the vec with 0 initially,
+/// before writing anything from that point
+fn vec_write_all<A>(pos_mut: &mut u64, vec: &mut Vec<u8, A>, buf: &[u8]) -> io::Result<usize>
+where
+    A: Allocator,
+{
+    let buf_len = buf.len();
+    let mut pos = reserve_and_pad(pos_mut, vec, buf_len)?;
+
+    // Write the buf then progress the vec forward if necessary
+    // Safety: we have ensured that the capacity is available
+    // and that all bytes get written up to pos
+    unsafe {
+        pos = vec_write_all_unchecked(pos, vec, buf);
+        if pos > vec.len() {
+            vec.set_len(pos);
+        }
+    };
+
+    // Bump us forward
+    *pos_mut += buf_len as u64;
+    Ok(buf_len)
+}
+
+/// Resizing `write_all_vectored` implementation for [`Cursor`].
+///
+/// Cursor is allowed to have a pre-allocated and initialised
+/// vector body, but with a position of 0. This means the [`Write`]
+/// will overwrite the contents of the vec.
+///
+/// This also allows for the vec body to be empty, but with a position of N.
+/// This means that [`Write`] will pad the vec with 0 initially,
+/// before writing anything from that point
+fn vec_write_all_vectored<A>(
+    pos_mut: &mut u64,
+    vec: &mut Vec<u8, A>,
+    bufs: &[IoSlice<'_>],
+) -> io::Result<usize>
+where
+    A: Allocator,
+{
+    // For safety reasons, we don't want this sum to overflow ever.
+    // If this saturates, the reserve should panic to avoid any unsound writing.
+    let buf_len = bufs.iter().fold(0usize, |a, b| a.saturating_add(b.len()));
+    let mut pos = reserve_and_pad(pos_mut, vec, buf_len)?;
+
+    // Write the buf then progress the vec forward if necessary
+    // Safety: we have ensured that the capacity is available
+    // and that all bytes get written up to the last pos
+    unsafe {
+        for buf in bufs {
+            pos = vec_write_all_unchecked(pos, vec, buf);
+        }
+        if pos > vec.len() {
+            vec.set_len(pos);
+        }
+    }
+
+    // Bump us forward
+    *pos_mut += buf_len as u64;
+    Ok(buf_len)
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl Write for Cursor<&mut [u8]> {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        slice_write(&mut self.pos, self.inner, buf)
+    }
+
+    #[inline]
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        slice_write_vectored(&mut self.pos, self.inner, bufs)
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        true
+    }
+
+    #[inline]
+    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
+        slice_write_all(&mut self.pos, self.inner, buf)
+    }
+
+    #[inline]
+    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        slice_write_all_vectored(&mut self.pos, self.inner, bufs)
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+#[stable(feature = "cursor_mut_vec", since = "1.25.0")]
+impl<A> Write for Cursor<&mut Vec<u8, A>>
+where
+    A: Allocator,
+{
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        vec_write_all(&mut self.pos, self.inner, buf)
+    }
+
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        vec_write_all_vectored(&mut self.pos, self.inner, bufs)
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        true
+    }
+
+    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
+        vec_write_all(&mut self.pos, self.inner, buf)?;
+        Ok(())
+    }
+
+    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        vec_write_all_vectored(&mut self.pos, self.inner, bufs)?;
+        Ok(())
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<A> Write for Cursor<Vec<u8, A>>
+where
+    A: Allocator,
+{
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        vec_write_all(&mut self.pos, &mut self.inner, buf)
+    }
+
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        vec_write_all_vectored(&mut self.pos, &mut self.inner, bufs)
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        true
+    }
+
+    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
+        vec_write_all(&mut self.pos, &mut self.inner, buf)?;
+        Ok(())
+    }
+
+    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        vec_write_all_vectored(&mut self.pos, &mut self.inner, bufs)?;
+        Ok(())
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+#[stable(feature = "cursor_box_slice", since = "1.5.0")]
+impl<A> Write for Cursor<Box<[u8], A>>
+where
+    A: Allocator,
+{
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        slice_write(&mut self.pos, &mut self.inner, buf)
+    }
+
+    #[inline]
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        slice_write_vectored(&mut self.pos, &mut self.inner, bufs)
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        true
+    }
+
+    #[inline]
+    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
+        slice_write_all(&mut self.pos, &mut self.inner, buf)
+    }
+
+    #[inline]
+    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        slice_write_all_vectored(&mut self.pos, &mut self.inner, bufs)
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+#[stable(feature = "cursor_array", since = "1.61.0")]
+impl<const N: usize> Write for Cursor<[u8; N]> {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        slice_write(&mut self.pos, &mut self.inner, buf)
+    }
+
+    #[inline]
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        slice_write_vectored(&mut self.pos, &mut self.inner, bufs)
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        true
+    }
+
+    #[inline]
+    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
+        slice_write_all(&mut self.pos, &mut self.inner, buf)
+    }
+
+    #[inline]
+    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        slice_write_all_vectored(&mut self.pos, &mut self.inner, bufs)
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}

crates/io/src/io/error/repr_bitpacked.rs

@@ -0,0 +1,411 @@
+//! This is a densely packed error representation which is used on targets with
+//! 64-bit pointers.
+//!
+//! (Note that `bitpacked` vs `unpacked` here has no relationship to
+//! `#[repr(packed)]`, it just refers to attempting to use any available bits in
+//! a more clever manner than `rustc`'s default layout algorithm would).
+//!
+//! Conceptually, it stores the same data as the "unpacked" equivalent we use on
+//! other targets. Specifically, you can imagine it as an optimized version of
+//! the following enum (which is roughly equivalent to what's stored by
+//! `repr_unpacked::Repr`, e.g. `super::ErrorData<Box<Custom>>`):
+//!
+//! ```ignore (exposition-only)
+//! enum ErrorData {
+//!    Os(i32),
+//!    Simple(ErrorKind),
+//!    SimpleMessage(&'static SimpleMessage),
+//!    Custom(Box<Custom>),
+//! }
+//! ```
+//!
+//! However, it packs this data into a 64bit non-zero value.
+//!
+//! This optimization not only allows `io::Error` to occupy a single pointer,
+//! but improves `io::Result` as well, especially for situations like
+//! `io::Result<()>` (which is now 64 bits) or `io::Result<u64>` (which is now
+//! 128 bits), which are quite common.
+//!
+//! # Layout
+//! Tagged values are 64 bits, with the 2 least significant bits used for the
+//! tag. This means there are 4 "variants":
+//!
+//! - **Tag 0b00**: The first variant is equivalent to
+//!   `ErrorData::SimpleMessage`, and holds a `&'static SimpleMessage` directly.
+//!
+//!   `SimpleMessage` has an alignment >= 4 (which is requested with
+//!   `#[repr(align)]` and checked statically at the bottom of this file), which
+//!   means every `&'static SimpleMessage` should have the both tag bits as 0,
+//!   meaning its tagged and untagged representation are equivalent.
+//!
+//!   This means we can skip tagging it, which is necessary as this variant can
+//!   be constructed from a `const fn`, which probably cannot tag pointers (or
+//!   at least it would be difficult).
+//!
+//! - **Tag 0b01**: The other pointer variant holds the data for
+//!   `ErrorData::Custom` and the remaining 62 bits are used to store a
+//!   `Box<Custom>`. `Custom` also has alignment >= 4, so the bottom two bits
+//!   are free to use for the tag.
+//!
+//!   The only important thing to note is that `ptr::wrapping_add` and
+//!   `ptr::wrapping_sub` are used to tag the pointer, rather than bitwise
+//!   operations. This should preserve the pointer's provenance, which would
+//!   otherwise be lost.
+//!
+//! - **Tag 0b10**: Holds the data for `ErrorData::Os(i32)`. We store the `i32`
+//!   in the pointer's most significant 32 bits, and don't use the bits `2..32`
+//!   for anything. Using the top 32 bits is just to let us easily recover the
+//!   `i32` code with the correct sign.
+//!
+//! - **Tag 0b11**: Holds the data for `ErrorData::Simple(ErrorKind)`. This
+//!   stores the `ErrorKind` in the top 32 bits as well, although it doesn't
+//!   occupy nearly that many. Most of the bits are unused here, but it's not
+//!   like we need them for anything else yet.
+//!
+//! # Use of `NonNull<()>`
+//!
+//! Everything is stored in a `NonNull<()>`, which is odd, but actually serves a
+//! purpose.
+//!
+//! Conceptually you might think of this more like:
+//!
+//! ```ignore (exposition-only)
+//! union Repr {
+//!     // holds integer (Simple/Os) variants, and
+//!     // provides access to the tag bits.
+//!     bits: NonZero<u64>,
+//!     // Tag is 0, so this is stored untagged.
+//!     msg: &'static SimpleMessage,
+//!     // Tagged (offset) `Box<Custom>` pointer.
+//!     tagged_custom: NonNull<()>,
+//! }
+//! ```
+//!
+//! But there are a few problems with this:
+//!
+//! 1. Union access is equivalent to a transmute, so this representation would
+//!    require we transmute between integers and pointers in at least one
+//!    direction, which may be UB (and even if not, it is likely harder for a
+//!    compiler to reason about than explicit ptr->int operations).
+//!
+//! 2. Even if all fields of a union have a niche, the union itself doesn't,
+//!    although this may change in the future. This would make things like
+//!    `io::Result<()>` and `io::Result<usize>` larger, which defeats part of
+//!    the motivation of this bitpacking.
+//!
+//! Storing everything in a `NonZero<usize>` (or some other integer) would be a
+//! bit more traditional for pointer tagging, but it would lose provenance
+//! information, couldn't be constructed from a `const fn`, and would probably
+//! run into other issues as well.
+//!
+//! The `NonNull<()>` seems like the only alternative, even if it's fairly odd
+//! to use a pointer type to store something that may hold an integer, some of
+//! the time.
+
+use core::marker::PhantomData;
+use core::num::NonZeroUsize;
+use core::ptr::NonNull;
+
+use super::{Custom, ErrorData, ErrorKind, RawOsError, SimpleMessage};
+
+// The 2 least-significant bits are used as tag.
+const TAG_MASK: usize = 0b11;
+const TAG_SIMPLE_MESSAGE: usize = 0b00;
+const TAG_CUSTOM: usize = 0b01;
+const TAG_OS: usize = 0b10;
+const TAG_SIMPLE: usize = 0b11;
+
+/// The internal representation.
+///
+/// See the module docs for more, this is just a way to hack in a check that we
+/// indeed are not unwind-safe.
+///
+/// ```compile_fail,E0277
+/// fn is_unwind_safe<T: core::panic::UnwindSafe>() {}
+/// is_unwind_safe::<std::io::Error>();
+/// ```
+#[repr(transparent)]
+#[rustc_insignificant_dtor]
+pub(super) struct Repr(NonNull<()>, PhantomData<ErrorData<Box<Custom>>>);
+
+// All the types `Repr` stores internally are Send + Sync, and so is it.
+unsafe impl Send for Repr {}
+unsafe impl Sync for Repr {}
+
+impl Repr {
+    pub(super) fn new_custom(b: Box<Custom>) -> Self {
+        let p = Box::into_raw(b).cast::<u8>();
+        // Should only be possible if an allocator handed out a pointer with
+        // wrong alignment.
+        debug_assert_eq!(p.addr() & TAG_MASK, 0);
+        // Note: We know `TAG_CUSTOM <= size_of::<Custom>()` (static_assert at
+        // end of file), and both the start and end of the expression must be
+        // valid without address space wraparound due to `Box`'s semantics.
+        //
+        // This means it would be correct to implement this using `ptr::add`
+        // (rather than `ptr::wrapping_add`), but it's unclear this would give
+        // any benefit, so we just use `wrapping_add` instead.
+        let tagged = p.wrapping_add(TAG_CUSTOM).cast::<()>();
+        // Safety: `TAG_CUSTOM + p` is the same as `TAG_CUSTOM | p`,
+        // because `p`'s alignment means it isn't allowed to have any of the
+        // `TAG_BITS` set (you can verify that addition and bitwise-or are the
+        // same when the operands have no bits in common using a truth table).
+        //
+        // Then, `TAG_CUSTOM | p` is not zero, as that would require
+        // `TAG_CUSTOM` and `p` both be zero, and neither is (as `p` came from a
+        // box, and `TAG_CUSTOM` just... isn't zero -- it's `0b01`). Therefore,
+        // `TAG_CUSTOM + p` isn't zero and so `tagged` can't be, and the
+        // `new_unchecked` is safe.
+        let res = Self(unsafe { NonNull::new_unchecked(tagged) }, PhantomData);
+        // quickly smoke-check we encoded the right thing (This generally will
+        // only run in std's tests, unless the user uses -Zbuild-std)
+        debug_assert!(matches!(res.data(), ErrorData::Custom(_)), "repr(custom) encoding failed");
+        res
+    }
+
+    #[inline]
+    pub(super) fn new_os(code: RawOsError) -> Self {
+        let utagged = ((code as usize) << 32) | TAG_OS;
+        // Safety: `TAG_OS` is not zero, so the result of the `|` is not 0.
+        let res = Self(
+            NonNull::without_provenance(unsafe { NonZeroUsize::new_unchecked(utagged) }),
+            PhantomData,
+        );
+        // quickly smoke-check we encoded the right thing (This generally will
+        // only run in std's tests, unless the user uses -Zbuild-std)
+        debug_assert!(
+            matches!(res.data(), ErrorData::Os(c) if c == code),
+            "repr(os) encoding failed for {code}"
+        );
+        res
+    }
+
+    #[inline]
+    pub(super) fn new_simple(kind: ErrorKind) -> Self {
+        let utagged = ((kind as usize) << 32) | TAG_SIMPLE;
+        // Safety: `TAG_SIMPLE` is not zero, so the result of the `|` is not 0.
+        let res = Self(
+            NonNull::without_provenance(unsafe { NonZeroUsize::new_unchecked(utagged) }),
+            PhantomData,
+        );
+        // quickly smoke-check we encoded the right thing (This generally will
+        // only run in std's tests, unless the user uses -Zbuild-std)
+        debug_assert!(
+            matches!(res.data(), ErrorData::Simple(k) if k == kind),
+            "repr(simple) encoding failed {:?}",
+            kind,
+        );
+        res
+    }
+
+    #[inline]
+    pub(super) const fn new_simple_message(m: &'static SimpleMessage) -> Self {
+        // Safety: References are never null.
+        Self(unsafe { NonNull::new_unchecked(m as *const _ as *mut ()) }, PhantomData)
+    }
+
+    #[inline]
+    pub(super) fn data(&self) -> ErrorData<&Custom> {
+        // Safety: We're a Repr, decode_repr is fine.
+        unsafe { decode_repr(self.0, |c| &*c) }
+    }
+
+    #[inline]
+    pub(super) fn data_mut(&mut self) -> ErrorData<&mut Custom> {
+        // Safety: We're a Repr, decode_repr is fine.
+        unsafe { decode_repr(self.0, |c| &mut *c) }
+    }
+
+    #[inline]
+    pub(super) fn into_data(self) -> ErrorData<Box<Custom>> {
+        let this = core::mem::ManuallyDrop::new(self);
+        // Safety: We're a Repr, decode_repr is fine. The `Box::from_raw` is
+        // safe because we prevent double-drop using `ManuallyDrop`.
+        unsafe { decode_repr(this.0, |p| Box::from_raw(p)) }
+    }
+}
+
+impl Drop for Repr {
+    #[inline]
+    fn drop(&mut self) {
+        // Safety: We're a Repr, decode_repr is fine. The `Box::from_raw` is
+        // safe because we're being dropped.
+        unsafe {
+            let _ = decode_repr(self.0, |p| Box::<Custom>::from_raw(p));
+        }
+    }
+}
+
+// Shared helper to decode a `Repr`'s internal pointer into an ErrorData.
+//
+// Safety: `ptr`'s bits should be encoded as described in the document at the
+// top (it should `some_repr.0`)
+#[inline]
+unsafe fn decode_repr<C, F>(ptr: NonNull<()>, make_custom: F) -> ErrorData<C>
+where
+    F: FnOnce(*mut Custom) -> C,
+{
+    let bits = ptr.as_ptr().addr();
+    match bits & TAG_MASK {
+        TAG_OS => {
+            let code = ((bits as i64) >> 32) as RawOsError;
+            ErrorData::Os(code)
+        }
+        TAG_SIMPLE => {
+            let kind_bits = (bits >> 32) as u32;
+            let kind = kind_from_prim(kind_bits).unwrap_or_else(|| {
+                debug_assert!(false, "Invalid io::error::Repr bits: `Repr({:#018x})`", bits);
+                // This means the `ptr` passed in was not valid, which violates
+                // the unsafe contract of `decode_repr`.
+                //
+                // Using this rather than unwrap meaningfully improves the code
+                // for callers which only care about one variant (usually
+                // `Custom`)
+                unsafe { core::hint::unreachable_unchecked() };
+            });
+            ErrorData::Simple(kind)
+        }
+        TAG_SIMPLE_MESSAGE => {
+            // SAFETY: per tag
+            unsafe { ErrorData::SimpleMessage(&*ptr.cast::<SimpleMessage>().as_ptr()) }
+        }
+        TAG_CUSTOM => {
+            // It would be correct for us to use `ptr::byte_sub` here (see the
+            // comment above the `wrapping_add` call in `new_custom` for why),
+            // but it isn't clear that it makes a difference, so we don't.
+            let custom = ptr.as_ptr().wrapping_byte_sub(TAG_CUSTOM).cast::<Custom>();
+            ErrorData::Custom(make_custom(custom))
+        }
+        _ => {
+            // Can't happen, and compiler can tell
+            unreachable!();
+        }
+    }
+}
+
+// This compiles to the same code as the check+transmute, but doesn't require
+// unsafe, or to hard-code max ErrorKind or its size in a way the compiler
+// couldn't verify.
+#[inline]
+fn kind_from_prim(ek: u32) -> Option<ErrorKind> {
+    macro_rules! from_prim {
+        ($prim:expr => $Enum:ident { $($Variant:ident),* $(,)? }) => {{
+            // Force a compile error if the list gets out of date.
+            const _: fn(e: $Enum) = |e: $Enum| match e {
+                $($Enum::$Variant => ()),*
+            };
+            match $prim {
+                $(v if v == ($Enum::$Variant as _) => Some($Enum::$Variant),)*
+                _ => None,
+            }
+        }}
+    }
+    from_prim!(ek => ErrorKind {
+        NotFound,
+        PermissionDenied,
+        ConnectionRefused,
+        ConnectionReset,
+        HostUnreachable,
+        NetworkUnreachable,
+        ConnectionAborted,
+        NotConnected,
+        AddrInUse,
+        AddrNotAvailable,
+        NetworkDown,
+        BrokenPipe,
+        AlreadyExists,
+        WouldBlock,
+        NotADirectory,
+        IsADirectory,
+        DirectoryNotEmpty,
+        ReadOnlyFilesystem,
+        FilesystemLoop,
+        StaleNetworkFileHandle,
+        InvalidInput,
+        InvalidData,
+        TimedOut,
+        WriteZero,
+        StorageFull,
+        NotSeekable,
+        QuotaExceeded,
+        FileTooLarge,
+        ResourceBusy,
+        ExecutableFileBusy,
+        Deadlock,
+        CrossesDevices,
+        TooManyLinks,
+        InvalidFilename,
+        ArgumentListTooLong,
+        Interrupted,
+        Other,
+        UnexpectedEof,
+        Unsupported,
+        OutOfMemory,
+        InProgress,
+        Uncategorized,
+    })
+}
+
+// Some static checking to alert us if a change breaks any of the assumptions
+// that our encoding relies on for correctness and soundness. (Some of these are
+// a bit overly thorough/cautious, admittedly)
+//
+// If any of these are hit on a platform that std supports, we should likely
+// just use `repr_unpacked.rs` there instead (unless the fix is easy).
+macro_rules! static_assert {
+    ($condition:expr) => {
+        const _: () = assert!($condition);
+    };
+    (@usize_eq: $lhs:expr, $rhs:expr) => {
+        const _: [(); $lhs] = [(); $rhs];
+    };
+}
+
+// The bitpacking we use requires pointers be exactly 64 bits.
+static_assert!(@usize_eq: size_of::<NonNull<()>>(), 8);
+
+// We also require pointers and usize be the same size.
+static_assert!(@usize_eq: size_of::<NonNull<()>>(), size_of::<usize>());
+
+// `Custom` and `SimpleMessage` need to be thin pointers.
+static_assert!(@usize_eq: size_of::<&'static SimpleMessage>(), 8);
+static_assert!(@usize_eq: size_of::<Box<Custom>>(), 8);
+
+static_assert!((TAG_MASK + 1).is_power_of_two());
+// And they must have sufficient alignment.
+static_assert!(align_of::<SimpleMessage>() >= TAG_MASK + 1);
+static_assert!(align_of::<Custom>() >= TAG_MASK + 1);
+
+static_assert!(@usize_eq: TAG_MASK & TAG_SIMPLE_MESSAGE, TAG_SIMPLE_MESSAGE);
+static_assert!(@usize_eq: TAG_MASK & TAG_CUSTOM, TAG_CUSTOM);
+static_assert!(@usize_eq: TAG_MASK & TAG_OS, TAG_OS);
+static_assert!(@usize_eq: TAG_MASK & TAG_SIMPLE, TAG_SIMPLE);
+
+// This is obviously true (`TAG_CUSTOM` is `0b01`), but in `Repr::new_custom` we
+// offset a pointer by this value, and expect it to both be within the same
+// object, and to not wrap around the address space. See the comment in that
+// function for further details.
+//
+// Actually, at the moment we use `ptr::wrapping_add`, not `ptr::add`, so this
+// check isn't needed for that one, although the assertion that we don't
+// actually wrap around in that wrapping_add does simplify the safety reasoning
+// elsewhere considerably.
+static_assert!(size_of::<Custom>() >= TAG_CUSTOM);
+
+// These two store a payload which is allowed to be zero, so they must be
+// non-zero to preserve the `NonNull`'s range invariant.
+static_assert!(TAG_OS != 0);
+static_assert!(TAG_SIMPLE != 0);
+// We can't tag `SimpleMessage`s, the tag must be 0.
+static_assert!(@usize_eq: TAG_SIMPLE_MESSAGE, 0);
+
+// Check that the point of all of this still holds.
+//
+// We'd check against `io::Error`, but *technically* it's allowed to vary,
+// as it's not `#[repr(transparent)]`/`#[repr(C)]`. We could add that, but
+// the `#[repr()]` would show up in rustdoc, which might be seen as a stable
+// commitment.
+static_assert!(@usize_eq: size_of::<Repr>(), 8);
+static_assert!(@usize_eq: size_of::<Option<Repr>>(), 8);
+static_assert!(@usize_eq: size_of::<Result<(), Repr>>(), 8);
+static_assert!(@usize_eq: size_of::<Result<usize, Repr>>(), 16);

crates/io/src/io/error/repr_unpacked.rs

@@ -0,0 +1,50 @@
+//! This is a fairly simple unpacked error representation that's used on
+//! non-64bit targets, where the packed 64 bit representation wouldn't work, and
+//! would have no benefit.
+
+use super::{Custom, ErrorData, ErrorKind, RawOsError, SimpleMessage};
+
+type Inner = ErrorData<Box<Custom>>;
+
+pub(super) struct Repr(Inner);
+
+impl Repr {
+    #[inline]
+    pub(super) fn new_custom(b: Box<Custom>) -> Self {
+        Self(Inner::Custom(b))
+    }
+    #[inline]
+    pub(super) fn new_os(code: RawOsError) -> Self {
+        Self(Inner::Os(code))
+    }
+    #[inline]
+    pub(super) fn new_simple(kind: ErrorKind) -> Self {
+        Self(Inner::Simple(kind))
+    }
+    #[inline]
+    pub(super) const fn new_simple_message(m: &'static SimpleMessage) -> Self {
+        Self(Inner::SimpleMessage(m))
+    }
+    #[inline]
+    pub(super) fn into_data(self) -> ErrorData<Box<Custom>> {
+        self.0
+    }
+    #[inline]
+    pub(super) fn data(&self) -> ErrorData<&Custom> {
+        match &self.0 {
+            Inner::Os(c) => ErrorData::Os(*c),
+            Inner::Simple(k) => ErrorData::Simple(*k),
+            Inner::SimpleMessage(m) => ErrorData::SimpleMessage(*m),
+            Inner::Custom(m) => ErrorData::Custom(&*m),
+        }
+    }
+    #[inline]
+    pub(super) fn data_mut(&mut self) -> ErrorData<&mut Custom> {
+        match &mut self.0 {
+            Inner::Os(c) => ErrorData::Os(*c),
+            Inner::Simple(k) => ErrorData::Simple(*k),
+            Inner::SimpleMessage(m) => ErrorData::SimpleMessage(*m),
+            Inner::Custom(m) => ErrorData::Custom(&mut *m),
+        }
+    }
+}

crates/io/src/io/impls.rs

@@ -0,0 +1,715 @@
+
+use crate::alloc::Allocator;
+use crate::collections::VecDeque;
+use crate::io::{self, BorrowedCursor, BufRead, IoSlice, IoSliceMut, Read, Seek, SeekFrom, Write};
+use crate::{cmp, fmt, mem, str};
+
+// =============================================================================
+// Forwarding implementations
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<R: Read + ?Sized> Read for &mut R {
+    #[inline]
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        (**self).read(buf)
+    }
+
+    #[inline]
+    fn read_buf(&mut self, cursor: BorrowedCursor<'_>) -> io::Result<()> {
+        (**self).read_buf(cursor)
+    }
+
+    #[inline]
+    fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
+        (**self).read_vectored(bufs)
+    }
+
+    #[inline]
+    fn is_read_vectored(&self) -> bool {
+        (**self).is_read_vectored()
+    }
+
+    #[inline]
+    fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
+        (**self).read_to_end(buf)
+    }
+
+    #[inline]
+    fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> {
+        (**self).read_to_string(buf)
+    }
+
+    #[inline]
+    fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
+        (**self).read_exact(buf)
+    }
+
+    #[inline]
+    fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> io::Result<()> {
+        (**self).read_buf_exact(cursor)
+    }
+}
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<W: Write + ?Sized> Write for &mut W {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        (**self).write(buf)
+    }
+
+    #[inline]
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        (**self).write_vectored(bufs)
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        (**self).is_write_vectored()
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        (**self).flush()
+    }
+
+    #[inline]
+    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
+        (**self).write_all(buf)
+    }
+
+    #[inline]
+    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        (**self).write_all_vectored(bufs)
+    }
+
+    #[inline]
+    fn write_fmt(&mut self, fmt: fmt::Arguments<'_>) -> io::Result<()> {
+        (**self).write_fmt(fmt)
+    }
+}
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<S: Seek + ?Sized> Seek for &mut S {
+    #[inline]
+    fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
+        (**self).seek(pos)
+    }
+
+    #[inline]
+    fn rewind(&mut self) -> io::Result<()> {
+        (**self).rewind()
+    }
+
+    #[inline]
+    fn stream_len(&mut self) -> io::Result<u64> {
+        (**self).stream_len()
+    }
+
+    #[inline]
+    fn stream_position(&mut self) -> io::Result<u64> {
+        (**self).stream_position()
+    }
+
+    #[inline]
+    fn seek_relative(&mut self, offset: i64) -> io::Result<()> {
+        (**self).seek_relative(offset)
+    }
+}
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<B: BufRead + ?Sized> BufRead for &mut B {
+    #[inline]
+    fn fill_buf(&mut self) -> io::Result<&[u8]> {
+        (**self).fill_buf()
+    }
+
+    #[inline]
+    fn consume(&mut self, amt: usize) {
+        (**self).consume(amt)
+    }
+
+    #[inline]
+    fn has_data_left(&mut self) -> io::Result<bool> {
+        (**self).has_data_left()
+    }
+
+    #[inline]
+    fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> io::Result<usize> {
+        (**self).read_until(byte, buf)
+    }
+
+    #[inline]
+    fn skip_until(&mut self, byte: u8) -> io::Result<usize> {
+        (**self).skip_until(byte)
+    }
+
+    #[inline]
+    fn read_line(&mut self, buf: &mut String) -> io::Result<usize> {
+        (**self).read_line(buf)
+    }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<R: Read + ?Sized> Read for Box<R> {
+    #[inline]
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        (**self).read(buf)
+    }
+
+    #[inline]
+    fn read_buf(&mut self, cursor: BorrowedCursor<'_>) -> io::Result<()> {
+        (**self).read_buf(cursor)
+    }
+
+    #[inline]
+    fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
+        (**self).read_vectored(bufs)
+    }
+
+    #[inline]
+    fn is_read_vectored(&self) -> bool {
+        (**self).is_read_vectored()
+    }
+
+    #[inline]
+    fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
+        (**self).read_to_end(buf)
+    }
+
+    #[inline]
+    fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> {
+        (**self).read_to_string(buf)
+    }
+
+    #[inline]
+    fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
+        (**self).read_exact(buf)
+    }
+
+    #[inline]
+    fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> io::Result<()> {
+        (**self).read_buf_exact(cursor)
+    }
+}
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<W: Write + ?Sized> Write for Box<W> {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        (**self).write(buf)
+    }
+
+    #[inline]
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        (**self).write_vectored(bufs)
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        (**self).is_write_vectored()
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        (**self).flush()
+    }
+
+    #[inline]
+    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
+        (**self).write_all(buf)
+    }
+
+    #[inline]
+    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        (**self).write_all_vectored(bufs)
+    }
+
+    #[inline]
+    fn write_fmt(&mut self, fmt: fmt::Arguments<'_>) -> io::Result<()> {
+        (**self).write_fmt(fmt)
+    }
+}
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<S: Seek + ?Sized> Seek for Box<S> {
+    #[inline]
+    fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
+        (**self).seek(pos)
+    }
+
+    #[inline]
+    fn rewind(&mut self) -> io::Result<()> {
+        (**self).rewind()
+    }
+
+    #[inline]
+    fn stream_len(&mut self) -> io::Result<u64> {
+        (**self).stream_len()
+    }
+
+    #[inline]
+    fn stream_position(&mut self) -> io::Result<u64> {
+        (**self).stream_position()
+    }
+
+    #[inline]
+    fn seek_relative(&mut self, offset: i64) -> io::Result<()> {
+        (**self).seek_relative(offset)
+    }
+}
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<B: BufRead + ?Sized> BufRead for Box<B> {
+    #[inline]
+    fn fill_buf(&mut self) -> io::Result<&[u8]> {
+        (**self).fill_buf()
+    }
+
+    #[inline]
+    fn consume(&mut self, amt: usize) {
+        (**self).consume(amt)
+    }
+
+    #[inline]
+    fn has_data_left(&mut self) -> io::Result<bool> {
+        (**self).has_data_left()
+    }
+
+    #[inline]
+    fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> io::Result<usize> {
+        (**self).read_until(byte, buf)
+    }
+
+    #[inline]
+    fn skip_until(&mut self, byte: u8) -> io::Result<usize> {
+        (**self).skip_until(byte)
+    }
+
+    #[inline]
+    fn read_line(&mut self, buf: &mut String) -> io::Result<usize> {
+        (**self).read_line(buf)
+    }
+}
+
+// =============================================================================
+// In-memory buffer implementations
+
+/// Read is implemented for `&[u8]` by copying from the slice.
+///
+/// Note that reading updates the slice to point to the yet unread part.
+/// The slice will be empty when EOF is reached.
+#[stable(feature = "rust1", since = "1.0.0")]
+impl Read for &[u8] {
+    #[inline]
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        let amt = cmp::min(buf.len(), self.len());
+        let (a, b) = self.split_at(amt);
+
+        // First check if the amount of bytes we want to read is small:
+        // `copy_from_slice` will generally expand to a call to `memcpy`, and
+        // for a single byte the overhead is significant.
+        if amt == 1 {
+            buf[0] = a[0];
+        } else {
+            buf[..amt].copy_from_slice(a);
+        }
+
+        *self = b;
+        Ok(amt)
+    }
+
+    #[inline]
+    fn read_buf(&mut self, mut cursor: BorrowedCursor<'_>) -> io::Result<()> {
+        let amt = cmp::min(cursor.capacity(), self.len());
+        let (a, b) = self.split_at(amt);
+
+        cursor.append(a);
+
+        *self = b;
+        Ok(())
+    }
+
+    #[inline]
+    fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
+        let mut nread = 0;
+        for buf in bufs {
+            nread += self.read(buf)?;
+            if self.is_empty() {
+                break;
+            }
+        }
+
+        Ok(nread)
+    }
+
+    #[inline]
+    fn is_read_vectored(&self) -> bool {
+        true
+    }
+
+    #[inline]
+    fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
+        if buf.len() > self.len() {
+            // `read_exact` makes no promise about the content of `buf` if it
+            // fails so don't bother about that.
+            *self = &self[self.len()..];
+            return Err(io::Error::READ_EXACT_EOF);
+        }
+        let (a, b) = self.split_at(buf.len());
+
+        // First check if the amount of bytes we want to read is small:
+        // `copy_from_slice` will generally expand to a call to `memcpy`, and
+        // for a single byte the overhead is significant.
+        if buf.len() == 1 {
+            buf[0] = a[0];
+        } else {
+            buf.copy_from_slice(a);
+        }
+
+        *self = b;
+        Ok(())
+    }
+
+    #[inline]
+    fn read_buf_exact(&mut self, mut cursor: BorrowedCursor<'_>) -> io::Result<()> {
+        if cursor.capacity() > self.len() {
+            // Append everything we can to the cursor.
+            cursor.append(*self);
+            *self = &self[self.len()..];
+            return Err(io::Error::READ_EXACT_EOF);
+        }
+        let (a, b) = self.split_at(cursor.capacity());
+
+        cursor.append(a);
+
+        *self = b;
+        Ok(())
+    }
+
+    #[inline]
+    fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
+        let len = self.len();
+        buf.try_reserve(len)?;
+        buf.extend_from_slice(*self);
+        *self = &self[len..];
+        Ok(len)
+    }
+
+    #[inline]
+    fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> {
+        let content = str::from_utf8(self).map_err(|_| io::Error::INVALID_UTF8)?;
+        let len = self.len();
+        buf.try_reserve(len)?;
+        buf.push_str(content);
+        *self = &self[len..];
+        Ok(len)
+    }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl BufRead for &[u8] {
+    #[inline]
+    fn fill_buf(&mut self) -> io::Result<&[u8]> {
+        Ok(*self)
+    }
+
+    #[inline]
+    fn consume(&mut self, amt: usize) {
+        *self = &self[amt..];
+    }
+}
+
+/// Write is implemented for `&mut [u8]` by copying into the slice, overwriting
+/// its data.
+///
+/// Note that writing updates the slice to point to the yet unwritten part.
+/// The slice will be empty when it has been completely overwritten.
+///
+/// If the number of bytes to be written exceeds the size of the slice, write operations will
+/// return short writes: ultimately, `Ok(0)`; in this situation, `write_all` returns an error of
+/// kind `ErrorKind::WriteZero`.
+#[stable(feature = "rust1", since = "1.0.0")]
+impl Write for &mut [u8] {
+    #[inline]
+    fn write(&mut self, data: &[u8]) -> io::Result<usize> {
+        let amt = cmp::min(data.len(), self.len());
+        let (a, b) = mem::take(self).split_at_mut(amt);
+        a.copy_from_slice(&data[..amt]);
+        *self = b;
+        Ok(amt)
+    }
+
+    #[inline]
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        let mut nwritten = 0;
+        for buf in bufs {
+            nwritten += self.write(buf)?;
+            if self.is_empty() {
+                break;
+            }
+        }
+
+        Ok(nwritten)
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        true
+    }
+
+    #[inline]
+    fn write_all(&mut self, data: &[u8]) -> io::Result<()> {
+        if self.write(data)? < data.len() { Err(io::Error::WRITE_ALL_EOF) } else { Ok(()) }
+    }
+
+    #[inline]
+    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        for buf in bufs {
+            if self.write(buf)? < buf.len() {
+                return Err(io::Error::WRITE_ALL_EOF);
+            }
+        }
+        Ok(())
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+/// Write is implemented for `Vec<u8>` by appending to the vector.
+/// The vector will grow as needed.
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<A: Allocator> Write for Vec<u8, A> {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.extend_from_slice(buf);
+        Ok(buf.len())
+    }
+
+    #[inline]
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        let len = bufs.iter().map(|b| b.len()).sum();
+        self.reserve(len);
+        for buf in bufs {
+            self.extend_from_slice(buf);
+        }
+        Ok(len)
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        true
+    }
+
+    #[inline]
+    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
+        self.extend_from_slice(buf);
+        Ok(())
+    }
+
+    #[inline]
+    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        self.write_vectored(bufs)?;
+        Ok(())
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+/// Read is implemented for `VecDeque<u8>` by consuming bytes from the front of the `VecDeque`.
+#[stable(feature = "vecdeque_read_write", since = "1.63.0")]
+impl<A: Allocator> Read for VecDeque<u8, A> {
+    /// Fill `buf` with the contents of the "front" slice as returned by
+    /// [`as_slices`][`VecDeque::as_slices`]. If the contained byte slices of the `VecDeque` are
+    /// discontiguous, multiple calls to `read` will be needed to read the entire content.
+    #[inline]
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        let (ref mut front, _) = self.as_slices();
+        let n = Read::read(front, buf)?;
+        self.drain(..n);
+        Ok(n)
+    }
+
+    #[inline]
+    fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
+        let (front, back) = self.as_slices();
+
+        // Use only the front buffer if it is big enough to fill `buf`, else use
+        // the back buffer too.
+        match buf.split_at_mut_checked(front.len()) {
+            None => buf.copy_from_slice(&front[..buf.len()]),
+            Some((buf_front, buf_back)) => match back.split_at_checked(buf_back.len()) {
+                Some((back, _)) => {
+                    buf_front.copy_from_slice(front);
+                    buf_back.copy_from_slice(back);
+                }
+                None => {
+                    self.clear();
+                    return Err(io::Error::READ_EXACT_EOF);
+                }
+            },
+        }
+
+        self.drain(..buf.len());
+        Ok(())
+    }
+
+    #[inline]
+    fn read_buf(&mut self, cursor: BorrowedCursor<'_>) -> io::Result<()> {
+        let (ref mut front, _) = self.as_slices();
+        let n = cmp::min(cursor.capacity(), front.len());
+        Read::read_buf(front, cursor)?;
+        self.drain(..n);
+        Ok(())
+    }
+
+    #[inline]
+    fn read_buf_exact(&mut self, mut cursor: BorrowedCursor<'_>) -> io::Result<()> {
+        let len = cursor.capacity();
+        let (front, back) = self.as_slices();
+
+        match front.split_at_checked(cursor.capacity()) {
+            Some((front, _)) => cursor.append(front),
+            None => {
+                cursor.append(front);
+                match back.split_at_checked(cursor.capacity()) {
+                    Some((back, _)) => cursor.append(back),
+                    None => {
+                        cursor.append(back);
+                        self.clear();
+                        return Err(io::Error::READ_EXACT_EOF);
+                    }
+                }
+            }
+        }
+
+        self.drain(..len);
+        Ok(())
+    }
+
+    #[inline]
+    fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
+        // The total len is known upfront so we can reserve it in a single call.
+        let len = self.len();
+        buf.try_reserve(len)?;
+
+        let (front, back) = self.as_slices();
+        buf.extend_from_slice(front);
+        buf.extend_from_slice(back);
+        self.clear();
+        Ok(len)
+    }
+
+    #[inline]
+    fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> {
+        // SAFETY: We only append to the buffer
+        unsafe { io::append_to_string(buf, |buf| self.read_to_end(buf)) }
+    }
+}
+
+/// BufRead is implemented for `VecDeque<u8>` by reading bytes from the front of the `VecDeque`.
+#[stable(feature = "vecdeque_buf_read", since = "1.75.0")]
+impl<A: Allocator> BufRead for VecDeque<u8, A> {
+    /// Returns the contents of the "front" slice as returned by
+    /// [`as_slices`][`VecDeque::as_slices`]. If the contained byte slices of the `VecDeque` are
+    /// discontiguous, multiple calls to `fill_buf` will be needed to read the entire content.
+    #[inline]
+    fn fill_buf(&mut self) -> io::Result<&[u8]> {
+        let (front, _) = self.as_slices();
+        Ok(front)
+    }
+
+    #[inline]
+    fn consume(&mut self, amt: usize) {
+        self.drain(..amt);
+    }
+}
+
+/// Write is implemented for `VecDeque<u8>` by appending to the `VecDeque`, growing it as needed.
+#[stable(feature = "vecdeque_read_write", since = "1.63.0")]
+impl<A: Allocator> Write for VecDeque<u8, A> {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.extend(buf);
+        Ok(buf.len())
+    }
+
+    #[inline]
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        let len = bufs.iter().map(|b| b.len()).sum();
+        self.reserve(len);
+        for buf in bufs {
+            self.extend(&**buf);
+        }
+        Ok(len)
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        true
+    }
+
+    #[inline]
+    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
+        self.extend(buf);
+        Ok(())
+    }
+
+    #[inline]
+    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        self.write_vectored(bufs)?;
+        Ok(())
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+#[unstable(feature = "read_buf", issue = "78485")]
+impl<'a> io::Write for core::io::BorrowedCursor<'a> {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        let amt = cmp::min(buf.len(), self.capacity());
+        self.append(&buf[..amt]);
+        Ok(amt)
+    }
+
+    #[inline]
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        let mut nwritten = 0;
+        for buf in bufs {
+            let n = self.write(buf)?;
+            nwritten += n;
+            if n < buf.len() {
+                break;
+            }
+        }
+        Ok(nwritten)
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        true
+    }
+
+    #[inline]
+    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
+        if self.write(buf)? < buf.len() { Err(io::Error::WRITE_ALL_EOF) } else { Ok(()) }
+    }
+
+    #[inline]
+    fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        for buf in bufs {
+            if self.write(buf)? < buf.len() {
+                return Err(io::Error::WRITE_ALL_EOF);
+            }
+        }
+        Ok(())
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}

crates/io/src/io/prelude.rs

@@ -0,0 +1,14 @@
+//! The I/O Prelude.
+//!
+//! The purpose of this module is to alleviate imports of many common I/O traits
+//! by adding a glob import to the top of I/O heavy modules:
+//!
+//! ```
+//! # #![allow(unused_imports)]
+//! use std::io::prelude::*;
+//! ```
+
+#![stable(feature = "rust1", since = "1.0.0")]
+
+#[stable(feature = "rust1", since = "1.0.0")]
+pub use super::{BufRead, Read, Seek, Write};

crates/io/src/io/util.rs

@@ -0,0 +1,446 @@
+#![allow(missing_copy_implementations)]
+
+
+use crate::fmt;
+use crate::io::{
+    self, BorrowedCursor, BufRead, IoSlice, IoSliceMut, Read, Seek, SeekFrom, SizeHint, Write,
+};
+
+/// `Empty` ignores any data written via [`Write`], and will always be empty
+/// (returning zero bytes) when read via [`Read`].
+///
+/// This struct is generally created by calling [`empty()`]. Please
+/// see the documentation of [`empty()`] for more details.
+#[stable(feature = "rust1", since = "1.0.0")]
+#[non_exhaustive]
+#[derive(Copy, Clone, Debug, Default)]
+pub struct Empty;
+
+/// Creates a value that is always at EOF for reads, and ignores all data written.
+///
+/// All calls to [`write`] on the returned instance will return [`Ok(buf.len())`]
+/// and the contents of the buffer will not be inspected.
+///
+/// All calls to [`read`] from the returned reader will return [`Ok(0)`].
+///
+/// [`Ok(buf.len())`]: Ok
+/// [`Ok(0)`]: Ok
+///
+/// [`write`]: Write::write
+/// [`read`]: Read::read
+///
+/// # Examples
+///
+/// ```rust
+/// use std::io::{self, Write};
+///
+/// let buffer = vec![1, 2, 3, 5, 8];
+/// let num_bytes = io::empty().write(&buffer).unwrap();
+/// assert_eq!(num_bytes, 5);
+/// ```
+///
+///
+/// ```rust
+/// use std::io::{self, Read};
+///
+/// let mut buffer = String::new();
+/// io::empty().read_to_string(&mut buffer).unwrap();
+/// assert!(buffer.is_empty());
+/// ```
+#[must_use]
+#[stable(feature = "rust1", since = "1.0.0")]
+#[rustc_const_stable(feature = "const_io_structs", since = "1.79.0")]
+pub const fn empty() -> Empty {
+    Empty
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl Read for Empty {
+    #[inline]
+    fn read(&mut self, _buf: &mut [u8]) -> io::Result<usize> {
+        Ok(0)
+    }
+
+    #[inline]
+    fn read_buf(&mut self, _cursor: BorrowedCursor<'_>) -> io::Result<()> {
+        Ok(())
+    }
+
+    #[inline]
+    fn read_vectored(&mut self, _bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
+        Ok(0)
+    }
+
+    #[inline]
+    fn is_read_vectored(&self) -> bool {
+        // Do not force `Chain<Empty, T>` or `Chain<T, Empty>` to use vectored
+        // reads, unless the other reader is vectored.
+        false
+    }
+
+    #[inline]
+    fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
+        if !buf.is_empty() { Err(io::Error::READ_EXACT_EOF) } else { Ok(()) }
+    }
+
+    #[inline]
+    fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> io::Result<()> {
+        if cursor.capacity() != 0 { Err(io::Error::READ_EXACT_EOF) } else { Ok(()) }
+    }
+
+    #[inline]
+    fn read_to_end(&mut self, _buf: &mut Vec<u8>) -> io::Result<usize> {
+        Ok(0)
+    }
+
+    #[inline]
+    fn read_to_string(&mut self, _buf: &mut String) -> io::Result<usize> {
+        Ok(0)
+    }
+}
+#[stable(feature = "rust1", since = "1.0.0")]
+impl BufRead for Empty {
+    #[inline]
+    fn fill_buf(&mut self) -> io::Result<&[u8]> {
+        Ok(&[])
+    }
+
+    #[inline]
+    fn consume(&mut self, _n: usize) {}
+
+    #[inline]
+    fn has_data_left(&mut self) -> io::Result<bool> {
+        Ok(false)
+    }
+
+    #[inline]
+    fn read_until(&mut self, _byte: u8, _buf: &mut Vec<u8>) -> io::Result<usize> {
+        Ok(0)
+    }
+
+    #[inline]
+    fn skip_until(&mut self, _byte: u8) -> io::Result<usize> {
+        Ok(0)
+    }
+
+    #[inline]
+    fn read_line(&mut self, _buf: &mut String) -> io::Result<usize> {
+        Ok(0)
+    }
+}
+
+#[stable(feature = "empty_seek", since = "1.51.0")]
+impl Seek for Empty {
+    #[inline]
+    fn seek(&mut self, _pos: SeekFrom) -> io::Result<u64> {
+        Ok(0)
+    }
+
+    #[inline]
+    fn stream_len(&mut self) -> io::Result<u64> {
+        Ok(0)
+    }
+
+    #[inline]
+    fn stream_position(&mut self) -> io::Result<u64> {
+        Ok(0)
+    }
+}
+
+impl SizeHint for Empty {
+    #[inline]
+    fn upper_bound(&self) -> Option<usize> {
+        Some(0)
+    }
+}
+
+#[stable(feature = "empty_write", since = "1.73.0")]
+impl Write for Empty {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        Ok(buf.len())
+    }
+
+    #[inline]
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        let total_len = bufs.iter().map(|b| b.len()).sum();
+        Ok(total_len)
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        true
+    }
+
+    #[inline]
+    fn write_all(&mut self, _buf: &[u8]) -> io::Result<()> {
+        Ok(())
+    }
+
+    #[inline]
+    fn write_all_vectored(&mut self, _bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        Ok(())
+    }
+
+    #[inline]
+    fn write_fmt(&mut self, _args: fmt::Arguments<'_>) -> io::Result<()> {
+        Ok(())
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+#[stable(feature = "empty_write", since = "1.73.0")]
+impl Write for &Empty {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        Ok(buf.len())
+    }
+
+    #[inline]
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        let total_len = bufs.iter().map(|b| b.len()).sum();
+        Ok(total_len)
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        true
+    }
+
+    #[inline]
+    fn write_all(&mut self, _buf: &[u8]) -> io::Result<()> {
+        Ok(())
+    }
+
+    #[inline]
+    fn write_all_vectored(&mut self, _bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        Ok(())
+    }
+
+    #[inline]
+    fn write_fmt(&mut self, _args: fmt::Arguments<'_>) -> io::Result<()> {
+        Ok(())
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+/// A reader which yields one byte over and over and over and over and over and...
+///
+/// This struct is generally created by calling [`repeat()`]. Please
+/// see the documentation of [`repeat()`] for more details.
+#[stable(feature = "rust1", since = "1.0.0")]
+pub struct Repeat {
+    byte: u8,
+}
+
+/// Creates an instance of a reader that infinitely repeats one byte.
+///
+/// All reads from this reader will succeed by filling the specified buffer with
+/// the given byte.
+///
+/// # Examples
+///
+/// ```
+/// use std::io::{self, Read};
+///
+/// let mut buffer = [0; 3];
+/// io::repeat(0b101).read_exact(&mut buffer).unwrap();
+/// assert_eq!(buffer, [0b101, 0b101, 0b101]);
+/// ```
+#[must_use]
+#[stable(feature = "rust1", since = "1.0.0")]
+#[rustc_const_stable(feature = "const_io_structs", since = "1.79.0")]
+pub const fn repeat(byte: u8) -> Repeat {
+    Repeat { byte }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl Read for Repeat {
+    #[inline]
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        buf.fill(self.byte);
+        Ok(buf.len())
+    }
+
+    #[inline]
+    fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
+        buf.fill(self.byte);
+        Ok(())
+    }
+
+    #[inline]
+    fn read_buf(&mut self, mut buf: BorrowedCursor<'_>) -> io::Result<()> {
+        // SAFETY: No uninit bytes are being written.
+        unsafe { buf.as_mut() }.write_filled(self.byte);
+        // SAFETY: the entire unfilled portion of buf has been initialized.
+        unsafe { buf.advance_unchecked(buf.capacity()) };
+        Ok(())
+    }
+
+    #[inline]
+    fn read_buf_exact(&mut self, buf: BorrowedCursor<'_>) -> io::Result<()> {
+        self.read_buf(buf)
+    }
+
+    /// This function is not supported by `io::Repeat`, because there's no end of its data
+    fn read_to_end(&mut self, _: &mut Vec<u8>) -> io::Result<usize> {
+        Err(io::Error::from(io::ErrorKind::OutOfMemory))
+    }
+
+    /// This function is not supported by `io::Repeat`, because there's no end of its data
+    fn read_to_string(&mut self, _: &mut String) -> io::Result<usize> {
+        Err(io::Error::from(io::ErrorKind::OutOfMemory))
+    }
+
+    #[inline]
+    fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
+        let mut nwritten = 0;
+        for buf in bufs {
+            nwritten += self.read(buf)?;
+        }
+        Ok(nwritten)
+    }
+
+    #[inline]
+    fn is_read_vectored(&self) -> bool {
+        true
+    }
+}
+
+impl SizeHint for Repeat {
+    #[inline]
+    fn lower_bound(&self) -> usize {
+        usize::MAX
+    }
+
+    #[inline]
+    fn upper_bound(&self) -> Option<usize> {
+        None
+    }
+}
+
+#[stable(feature = "std_debug", since = "1.16.0")]
+impl fmt::Debug for Repeat {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Repeat").finish_non_exhaustive()
+    }
+}
+
+/// A writer which will move data into the void.
+///
+/// This struct is generally created by calling [`sink()`]. Please
+/// see the documentation of [`sink()`] for more details.
+#[stable(feature = "rust1", since = "1.0.0")]
+#[non_exhaustive]
+#[derive(Copy, Clone, Debug, Default)]
+pub struct Sink;
+
+/// Creates an instance of a writer which will successfully consume all data.
+///
+/// All calls to [`write`] on the returned instance will return [`Ok(buf.len())`]
+/// and the contents of the buffer will not be inspected.
+///
+/// [`write`]: Write::write
+/// [`Ok(buf.len())`]: Ok
+///
+/// # Examples
+///
+/// ```rust
+/// use std::io::{self, Write};
+///
+/// let buffer = vec![1, 2, 3, 5, 8];
+/// let num_bytes = io::sink().write(&buffer).unwrap();
+/// assert_eq!(num_bytes, 5);
+/// ```
+#[must_use]
+#[stable(feature = "rust1", since = "1.0.0")]
+#[rustc_const_stable(feature = "const_io_structs", since = "1.79.0")]
+pub const fn sink() -> Sink {
+    Sink
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl Write for Sink {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        Ok(buf.len())
+    }
+
+    #[inline]
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        let total_len = bufs.iter().map(|b| b.len()).sum();
+        Ok(total_len)
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        true
+    }
+
+    #[inline]
+    fn write_all(&mut self, _buf: &[u8]) -> io::Result<()> {
+        Ok(())
+    }
+
+    #[inline]
+    fn write_all_vectored(&mut self, _bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        Ok(())
+    }
+
+    #[inline]
+    fn write_fmt(&mut self, _args: fmt::Arguments<'_>) -> io::Result<()> {
+        Ok(())
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+#[stable(feature = "write_mt", since = "1.48.0")]
+impl Write for &Sink {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        Ok(buf.len())
+    }
+
+    #[inline]
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        let total_len = bufs.iter().map(|b| b.len()).sum();
+        Ok(total_len)
+    }
+
+    #[inline]
+    fn is_write_vectored(&self) -> bool {
+        true
+    }
+
+    #[inline]
+    fn write_all(&mut self, _buf: &[u8]) -> io::Result<()> {
+        Ok(())
+    }
+
+    #[inline]
+    fn write_all_vectored(&mut self, _bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
+        Ok(())
+    }
+
+    #[inline]
+    fn write_fmt(&mut self, _args: fmt::Arguments<'_>) -> io::Result<()> {
+        Ok(())
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}

crates/io/src/lib.rs

@@ -1,299 +1,70 @@
-#![cfg_attr(any(not(feature = "std"), target_arch = "riscv64"), no_std)]
-pub mod error;
+#![cfg_attr(not(feature = "std"), no_std)]
+#![cfg_attr(not(feature = "std"), stable(feature = "rust1", since = "1.0.0"))]
+#![cfg_attr(
+    not(feature = "std"),
+    allow(
+        internal_features,
+        incomplete_features,
+        clippy::all,
+        dead_code,
+        unused_imports
+    )
+)]
+#![cfg_attr(
+    not(feature = "std"),
+    feature(
+        fmt_internals,
+        rustc_attrs,
+        decl_macro,
+        allow_internal_unstable,
+        staged_api,
+        core_io_borrowed_buf,
+        specialization,
+        prelude_import,
+        allocator_api,
+        slice_internals,
+        doc_notable_trait,
+        rustdoc_internals,
+        io_const_error,
+        maybe_uninit_array_assume_init,
+        try_with_capacity,
+        maybe_uninit_fill
+    )
+)]
 
-use error::IoError;
+#[cfg(not(feature = "std"))]
+pub mod io;
+#[cfg(not(feature = "std"))]
+pub(crate) mod sys;
+#[cfg(not(feature = "std"))]
+#[stable(feature = "rust1", since = "1.0.0")]
+pub use io::*;
 
-#[cfg(feature = "alloc")]
-extern crate alloc;
+#[cfg(not(feature = "std"))]
+mod std_prelude {
+    pub(crate) use core::prelude::rust_2024::*;
 
-#[cfg(feature = "alloc")]
-use alloc::string::String;
-#[cfg(feature = "alloc")]
-use alloc::vec::Vec;
-
-/// Provides IO error as an associated type.
-///
-/// Must be implemented for all types that also implement at least one of the following traits: `Read`, `Write`,
-/// `Seek`.
-pub trait IoBase {
-    /// Type of errors returned by input/output operations.
-    type Error: IoError;
+    #[allow(unused_imports)]
+    pub(crate) use super::alloc_crate::{
+        boxed::Box,
+        string::{String, ToString},
+        vec,
+        vec::Vec,
+    };
 }
+#[cfg(not(feature = "std"))]
+#[prelude_import]
+#[allow(unused_imports)]
+pub(crate) use std_prelude::*;
+#[cfg(not(feature = "std"))]
+extern crate alloc as alloc_crate;
+#[cfg(not(feature = "std"))]
+pub(crate) use alloc_crate::alloc;
 
-/// The `Read` trait allows for reading bytes from a source.
-///
-/// It is based on the `std::io::Read` trait.
-pub trait Read: IoBase {
-    /// Pull some bytes from this source into the specified buffer, returning how many bytes were read.
-    ///
-    /// This function does not provide any guarantees about whether it blocks waiting for data, but if an object needs
-    /// to block for a read and cannot, it will typically signal this via an Err return value.
-    ///
-    /// If the return value of this method is `Ok(n)`, then it must be guaranteed that `0 <= n <= buf.len()`. A nonzero
-    /// `n` value indicates that the buffer buf has been filled in with n bytes of data from this source. If `n` is
-    /// `0`, then it can indicate one of two scenarios:
-    ///
-    /// 1. This reader has reached its "end of file" and will likely no longer be able to produce bytes. Note that this
-    ///    does not mean that the reader will always no longer be able to produce bytes.
-    /// 2. The buffer specified was 0 bytes in length.
-    ///
-    /// It is not an error if the returned value `n` is smaller than the buffer size, even when the reader is not at
-    /// the end of the stream yet. This may happen for example because fewer bytes are actually available right now
-    /// (e. g. being close to end-of-file) or because `read()` was interrupted by a signal.
-    ///
-    /// # Errors
-    ///
-    /// If this function encounters any form of I/O or other error, an error will be returned. If an error is returned
-    /// then it must be guaranteed that no bytes were read.
-    /// An error for which `IoError::is_interrupted` returns true is non-fatal and the read operation should be retried
-    /// if there is nothing else to do.
-    fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error>;
+#[cfg(not(feature = "std"))]
+use alloc_crate::collections;
+#[cfg(not(feature = "std"))]
+use core::{cmp, error, fmt, hint, mem, ops, ptr, result, slice, str};
 
-    /// Read the exact number of bytes required to fill `buf`.
-    ///
-    /// This function reads as many bytes as necessary to completely fill the specified buffer `buf`.
-    ///
-    /// # Errors
-    ///
-    /// If this function encounters an error for which `IoError::is_interrupted` returns true then the error is ignored
-    /// and the operation will continue.
-    ///
-    /// If this function encounters an end of file before completely filling the buffer, it returns an error
-    /// instantiated by a call to `IoError::new_unexpected_eof_error`. The contents of `buf` are unspecified in this
-    /// case.
-    ///
-    /// If this function returns an error, it is unspecified how many bytes it has read, but it will never read more
-    /// than would be necessary to completely fill the buffer.
-    fn read_exact(&mut self, mut buf: &mut [u8]) -> Result<(), Self::Error> {
-        while !buf.is_empty() {
-            match self.read(buf) {
-                Ok(0) => break,
-                Ok(n) => {
-                    let tmp = buf;
-                    buf = &mut tmp[n..];
-                }
-                Err(ref e) if e.is_interrupted() => {}
-                Err(e) => return Err(e),
-            }
-        }
-        if buf.is_empty() {
-            Ok(())
-        } else {
-            Err(Self::Error::new_unexpected_eof_error())
-        }
-    }
-
-    #[cfg(feature = "alloc")]
-    fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Self::Error> {
-        const CHUNK_SIZE: usize = 32;
-        let start_len = buf.len();
-        loop {
-            let mut chunk_buf = [0; CHUNK_SIZE];
-            let read = self.read(&mut chunk_buf)?;
-            buf.extend_from_slice(&chunk_buf[..read]);
-
-            if read == 0 {
-                return Ok(buf.len() - start_len);
-            }
-        }
-    }
-
-    #[cfg(feature = "alloc")]
-    fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Self::Error> {
-        let read = self.read_to_end(unsafe { buf.as_mut_vec() })?;
-
-        if str::from_utf8(buf.as_bytes()).is_err() {
-            Err(Self::Error::new_invalid_utf8_error())
-        } else {
-            Ok(read)
-        }
-    }
-}
-
-/// The `Write` trait allows for writing bytes into the sink.
-///
-/// It is based on the `std::io::Write` trait.
-pub trait Write: IoBase {
-    /// Write a buffer into this writer, returning how many bytes were written.
-    ///
-    /// # Errors
-    ///
-    /// Each call to write may generate an I/O error indicating that the operation could not be completed. If an error
-    /// is returned then no bytes in the buffer were written to this writer.
-    /// It is not considered an error if the entire buffer could not be written to this writer.
-    fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error>;
-
-    /// Attempts to write an entire buffer into this writer.
-    ///
-    /// This method will continuously call `write` until there is no more data to be written or an error is returned.
-    /// Errors for which `IoError::is_interrupted` method returns true are being skipped. This method will not return
-    /// until the entire buffer has been successfully written or such an error occurs.
-    /// If `write` returns 0 before the entire buffer has been written this method will return an error instantiated by
-    /// a call to `IoError::new_write_zero_error`.
-    ///
-    /// # Errors
-    ///
-    /// This function will return the first error for which `IoError::is_interrupted` method returns false that `write`
-    /// returns.
-    fn write_all(&mut self, mut buf: &[u8]) -> Result<(), Self::Error> {
-        while !buf.is_empty() {
-            match self.write(buf) {
-                Ok(0) => {
-                    return Err(Self::Error::new_write_zero_error());
-                }
-                Ok(n) => buf = &buf[n..],
-                Err(ref e) if e.is_interrupted() => {}
-                Err(e) => return Err(e),
-            }
-        }
-        Ok(())
-    }
-
-    /// Flush this output stream, ensuring that all intermediately buffered contents reach their destination.
-    ///
-    /// # Errors
-    ///
-    /// It is considered an error if not all bytes could be written due to I/O errors or EOF being reached.
-    fn flush(&mut self) -> Result<(), Self::Error>;
-}
-
-/// Enumeration of possible methods to seek within an I/O object.
-///
-/// It is based on the `std::io::SeekFrom` enum.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum SeekFrom {
-    /// Sets the offset to the provided number of bytes.
-    Start(u64),
-    /// Sets the offset to the size of this object plus the specified number of bytes.
-    End(i64),
-    /// Sets the offset to the current position plus the specified number of bytes.
-    Current(i64),
-}
-
-/// The `Seek` trait provides a cursor which can be moved within a stream of bytes.
-///
-/// It is based on the `std::io::Seek` trait.
-pub trait Seek: IoBase {
-    /// Seek to an offset, in bytes, in a stream.
-    ///
-    /// A seek beyond the end of a stream or to a negative position is not allowed.
-    ///
-    /// If the seek operation completed successfully, this method returns the new position from the start of the
-    /// stream. That position can be used later with `SeekFrom::Start`.
-    ///
-    /// # Errors
-    /// Seeking to a negative offset is considered an error.
-    fn seek(&mut self, pos: SeekFrom) -> Result<u64, Self::Error>;
-}
-
-#[cfg(all(feature = "std", not(target_arch = "riscv64")))]
-impl From<SeekFrom> for std::io::SeekFrom {
-    fn from(from: SeekFrom) -> Self {
-        match from {
-            SeekFrom::Start(n) => std::io::SeekFrom::Start(n),
-            SeekFrom::End(n) => std::io::SeekFrom::End(n),
-            SeekFrom::Current(n) => std::io::SeekFrom::Current(n),
-        }
-    }
-}
-
-#[cfg(all(feature = "std", not(target_arch = "riscv64")))]
-impl From<std::io::SeekFrom> for SeekFrom {
-    fn from(from: std::io::SeekFrom) -> Self {
-        match from {
-            std::io::SeekFrom::Start(n) => SeekFrom::Start(n),
-            std::io::SeekFrom::End(n) => SeekFrom::End(n),
-            std::io::SeekFrom::Current(n) => SeekFrom::Current(n),
-        }
-    }
-}
-
-#[cfg(all(feature = "std", not(target_arch = "riscv64")))]
-impl IoBase for std::fs::File {
-    type Error = std::io::Error;
-}
-
-#[cfg(all(feature = "std", not(target_arch = "riscv64")))]
-impl<T: std::io::Read + IoBase<Error = std::io::Error>> Read for T {
-    fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
-        self.read(buf).map_err(Error::Io)
-    }
-    fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Self::Error> {
-        self.read_exact(buf).map_err(Error::Io)
-    }
-}
-
-#[cfg(all(feature = "std", not(target_arch = "riscv64")))]
-impl<T: std::io::Write + IoBase<Error = std::io::Error>> Write for T {
-    fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
-        self.write(buf).map_err(Error::Io)
-    }
-
-    fn write_all(&mut self, buf: &[u8]) -> Result<(), Self::Error> {
-        self.write_all(buf).map_err(Error::Io)
-    }
-
-    fn flush(&mut self) -> Result<(), Self::Error> {
-        self.flush().map_err(Error::Io)
-    }
-}
-
-#[cfg(all(feature = "std", not(target_arch = "riscv64")))]
-impl<T: std::io::Seek + IoBase<Error = std::io::Error>> Seek for T {
-    fn seek(&mut self, pos: SeekFrom) -> Result<u64, Self::Error> {
-        self.seek(pos.into()).map_err(Error::Io)
-    }
-}
-
-pub trait ReadLeExt {
-    type Error;
-    fn read_u8(&mut self) -> Result<u8, Self::Error>;
-    fn read_u16_le(&mut self) -> Result<u16, Self::Error>;
-    fn read_u32_le(&mut self) -> Result<u32, Self::Error>;
-}
-
-impl<T: Read> ReadLeExt for T {
-    type Error = <Self as IoBase>::Error;
-
-    fn read_u8(&mut self) -> Result<u8, Self::Error> {
-        let mut buf = [0_u8; 1];
-        self.read_exact(&mut buf)?;
-        Ok(buf[0])
-    }
-
-    fn read_u16_le(&mut self) -> Result<u16, Self::Error> {
-        let mut buf = [0_u8; 2];
-        self.read_exact(&mut buf)?;
-        Ok(u16::from_le_bytes(buf))
-    }
-
-    fn read_u32_le(&mut self) -> Result<u32, Self::Error> {
-        let mut buf = [0_u8; 4];
-        self.read_exact(&mut buf)?;
-        Ok(u32::from_le_bytes(buf))
-    }
-}
-
-#[allow(unused)]
-pub(crate) trait WriteLeExt {
-    type Error;
-    fn write_u8(&mut self, n: u8) -> Result<(), Self::Error>;
-    fn write_u16_le(&mut self, n: u16) -> Result<(), Self::Error>;
-    fn write_u32_le(&mut self, n: u32) -> Result<(), Self::Error>;
-}
-
-impl<T: Write> WriteLeExt for T {
-    type Error = <Self as IoBase>::Error;
-
-    fn write_u8(&mut self, n: u8) -> Result<(), Self::Error> {
-        self.write_all(&[n])
-    }
-
-    fn write_u16_le(&mut self, n: u16) -> Result<(), Self::Error> {
-        self.write_all(&n.to_le_bytes())
-    }
-
-    fn write_u32_le(&mut self, n: u32) -> Result<(), Self::Error> {
-        self.write_all(&n.to_le_bytes())
-    }
-}
+#[cfg(feature = "std")]
+pub use std::io::*;

crates/io/src/sys.rs

@@ -0,0 +1 @@
+pub(crate) mod io;

crates/io/src/sys/io/error/generic.rs

@@ -0,0 +1,15 @@
+pub fn errno() -> i32 {
+    0
+}
+
+pub fn is_interrupted(_code: i32) -> bool {
+    false
+}
+
+pub fn decode_error_kind(_code: i32) -> crate::io::ErrorKind {
+    crate::io::ErrorKind::Uncategorized
+}
+
+pub fn error_string(_errno: i32) -> String {
+    "operation successful".to_string()
+}

crates/io/src/sys/io/error/mod.rs

@@ -0,0 +1,4 @@
+mod generic;
+pub use generic::*;
+
+pub type RawOsError = i32;

crates/io/src/sys/io/io_slice/unsupported.rs

@@ -0,0 +1,52 @@
+use core::mem;
+
+#[derive(Copy, Clone)]
+pub struct IoSlice<'a>(&'a [u8]);
+
+impl<'a> IoSlice<'a> {
+    #[inline]
+    pub fn new(buf: &'a [u8]) -> IoSlice<'a> {
+        IoSlice(buf)
+    }
+
+    #[inline]
+    pub fn advance(&mut self, n: usize) {
+        self.0 = &self.0[n..]
+    }
+
+    #[inline]
+    pub const fn as_slice(&self) -> &'a [u8] {
+        self.0
+    }
+}
+
+pub struct IoSliceMut<'a>(&'a mut [u8]);
+
+impl<'a> IoSliceMut<'a> {
+    #[inline]
+    pub fn new(buf: &'a mut [u8]) -> IoSliceMut<'a> {
+        IoSliceMut(buf)
+    }
+
+    #[inline]
+    pub fn advance(&mut self, n: usize) {
+        let slice = mem::take(&mut self.0);
+        let (_, remaining) = slice.split_at_mut(n);
+        self.0 = remaining;
+    }
+
+    #[inline]
+    pub fn as_slice(&self) -> &[u8] {
+        self.0
+    }
+
+    #[inline]
+    pub const fn into_slice(self) -> &'a mut [u8] {
+        self.0
+    }
+
+    #[inline]
+    pub fn as_mut_slice(&mut self) -> &mut [u8] {
+        self.0
+    }
+}

crates/io/src/sys/io/is_terminal/unsupported.rs

@@ -0,0 +1,3 @@
+pub fn is_terminal<T>(_: &T) -> bool {
+    false
+}

crates/io/src/sys/io/kernel_copy/mod.rs

@@ -0,0 +1,16 @@
+
+pub enum CopyState {
+    #[cfg_attr(not(any(target_os = "linux", target_os = "android")), expect(dead_code))]
+    Ended(u64),
+    Fallback(u64),
+}
+
+        use crate::io::{Result, Read, Write};
+
+        pub fn kernel_copy<R: ?Sized, W: ?Sized>(_reader: &mut R, _writer: &mut W) -> Result<CopyState>
+        where
+            R: Read,
+            W: Write,
+        {
+            Ok(CopyState::Fallback(0))
+        }

crates/io/src/sys/io/mod.rs

@@ -0,0 +1,26 @@
+mod error;
+
+mod io_slice {
+    mod unsupported;
+    pub use unsupported::*;
+}
+
+mod is_terminal {
+    mod unsupported;
+    pub use unsupported::*;
+}
+
+mod kernel_copy;
+
+pub use error::{RawOsError, decode_error_kind, errno, error_string, is_interrupted};
+pub use io_slice::{IoSlice, IoSliceMut};
+pub use is_terminal::is_terminal;
+pub use kernel_copy::{CopyState, kernel_copy};
+
+// Bare metal platforms usually have very small amounts of RAM
+// (in the order of hundreds of KB)
+pub const DEFAULT_BUF_SIZE: usize = if cfg!(target_os = "espidf") {
+    512
+} else {
+    8 * 1024
+};

crates/kernel-macros/Cargo.toml

@@ -7,6 +7,6 @@ edition = "2024"
 proc-macro = true
 
 [dependencies]
-image = "0.25"
+image = { version = "0.25", default-features = false, features = ["png"] }
 syn = { version = "2", features = ["full"] }
 zyn = "0.5"

crates/os-std-macros/Cargo.toml

@@ -1,12 +0,0 @@
-[package]
-name = "os-std-macros"
-version = "0.1.0"
-edition = "2024"
-
-[lib]
-proc-macro = true
-
-[dependencies]
-proc-macro2 = "1"
-quote = "1"
-syn = { version = "2", features = ["full"] }

crates/shared/Cargo.toml

@@ -5,7 +5,7 @@ edition = "2024"
 
 [dependencies]
 bffs = { path = "../bffs" }
-io = { path = "../io" }
+io = { package = "no-std-io", path = "../io" }
 
 [features]
 kernel = []

crates/shared/src/fs.rs

@@ -1,4 +1,4 @@
-use io::{IoBase, Read, Write};
+use io::{Read, Write};
 
 use crate::syscall;
 
@@ -19,22 +19,18 @@ impl File {
     }
 }
 
-impl IoBase for File {
-    type Error = ();
-}
-
 impl Read for File {
-    fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
+    fn read(&mut self, buf: &mut [u8]) -> Result<usize, io::Error> {
         Ok(syscall::read(self.as_fd(), buf) as usize)
     }
 }
 
 impl Write for File {
-    fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
+    fn write(&mut self, buf: &[u8]) -> Result<usize, io::Error> {
         Ok(syscall::write(self.as_fd(), buf) as usize)
     }
 
-    fn flush(&mut self) -> Result<(), Self::Error> {
+    fn flush(&mut self) -> Result<(), io::Error> {
         todo!()
     }
 }

crates/shared/src/syscall.rs

@@ -1,10 +1,5 @@
 use core::{alloc::Layout, time::Duration};
 
-use bffs::path::Path;
-use io::SeekFrom;
-
-use crate::fs::File;
-
 #[repr(u64)]
 pub enum SysCall {
     Read = 0,
@@ -18,8 +13,7 @@ pub enum SysCall {
     ExecVE = 59,
     Exit = 60,
     NanoSleep = 101,
-    WriteIntTemp = 998,
-    WriteTemp = 999,
+    WaitPid = 247,
     Unimplemented = 1 << 31,
 }
 
@@ -37,8 +31,7 @@ impl From<u64> for SysCall {
             59 => SysCall::ExecVE,
             60 => SysCall::Exit,
             101 => SysCall::NanoSleep,
-            998 => SysCall::WriteIntTemp,
-            999 => SysCall::WriteTemp,
+            247 => SysCall::WaitPid,
             _ => SysCall::Unimplemented,
         }
     }
@@ -100,10 +93,12 @@ macro_rules! syscall {
     };
 }
 
-pub fn exit() {
+pub fn exit() -> ! {
     unsafe {
         syscall!(SysCall::Exit);
     }
+    #[allow(clippy::empty_loop)]
+    loop {}
 }
 
 pub fn sleep(duration: Duration) {
@@ -113,21 +108,8 @@ pub fn sleep(duration: Duration) {
     }
 }
 
-pub fn write_string_temp(content: &str) {
-    unsafe {
-        syscall!(
-            SysCall::WriteTemp,
-            content.as_ptr() as u64,
-            content.len() as u64
-        );
-    }
-}
-pub fn write_int_temp(content: u64) {
-    unsafe {
-        syscall!(SysCall::WriteIntTemp, content);
-    }
-}
-
+#[allow(unknown_lints)]
+#[allow(fuzzy_provenance_casts)]
 pub fn alloc(layout: Layout) -> *mut u8 {
     unsafe {
         let size = layout.size();
@@ -143,13 +125,12 @@ pub fn dealloc(ptr: *mut u8, layout: core::alloc::Layout) {
         syscall!(SysCall::Dealloc, ptr as u64, size as u64, align as u64);
     }
 }
-pub fn open<P: AsRef<Path>>(path: P) -> File {
+pub fn open(path: &str) -> u64 {
     unsafe {
-        let path_str = path.as_ref().as_str();
-        let ptr = path_str.as_ptr();
-        let size = path_str.len();
+        let ptr = path.as_ptr();
+        let size = path.len();
         let (fd, ..) = syscall!(SysCall::Open, ptr as u64, size as u64);
-        File::from_raw_fd(fd)
+        fd
     }
 }
 pub fn close(file_descriptor: u64) {
@@ -173,29 +154,36 @@ pub fn read(file_descriptor: u64, buf: &mut [u8]) -> u64 {
         len
     }
 }
-pub fn seek(file_descriptor: u64, seek: SeekFrom) {
+/// seek_type: 0 -> start, 1 -> end, 2 -> current
+pub fn seek(file_descriptor: u64, seek_type: u8, seek: u64) {
     unsafe {
-        let (discriminant, value) = match seek {
-            SeekFrom::Start(v) => (0, v),
-            SeekFrom::End(v) => (1, v as u64),
-            SeekFrom::Current(v) => (2, v as u64),
-        };
-        syscall!(SysCall::Seek, file_descriptor, discriminant, value);
+        syscall!(SysCall::Seek, file_descriptor, seek_type as u64, seek);
     }
 }
-pub fn spawn<P: AsRef<Path>>(path: P) {
+pub fn spawn(path: &str, argc: isize, argv: *const *const u8) -> u64 {
     unsafe {
-        let path_str = path.as_ref().as_str();
-        let ptr = path_str.as_ptr();
-        let size = path_str.len();
-        syscall!(SysCall::Spawn, ptr as u64, size as u64);
+        let ptr = path.as_ptr();
+        let size = path.len();
+        let (pid, ..) = syscall!(
+            SysCall::Spawn,
+            ptr as u64,
+            size as u64,
+            argc as u64,
+            argv as u64
+        );
+        pid
     }
 }
-pub fn execve<P: AsRef<Path>>(path: P) {
+pub fn execve(path: &str) {
     unsafe {
-        let path_str = path.as_ref().as_str();
-        let ptr = path_str.as_ptr();
-        let size = path_str.len();
+        let ptr = path.as_ptr();
+        let size = path.len();
         syscall!(SysCall::ExecVE, ptr as u64, size as u64);
     }
 }
+
+pub fn waitpid(pid: usize) {
+    unsafe {
+        syscall!(SysCall::WaitPid, pid as u64);
+    }
+}

crates/std/Cargo.toml

@@ -1,9 +0,0 @@
-[package]
-name = "std"
-version = "0.1.0"
-edition = "2024"
-
-[dependencies]
-os-std-macros = { path = "../os-std-macros" }
-shared = { path = "../shared", features = ["user"] }
-io = { path = "../io", features = ["alloc"] }

crates/std/src/alloc.rs

@@ -1,490 +0,0 @@
-//! Memory allocation APIs.
-//!
-//! In a given program, the standard library has one “global” memory allocator
-//! that is used for example by `Box<T>` and `Vec<T>`.
-//!
-//! Currently the default global allocator is unspecified. Libraries, however,
-//! like `cdylib`s and `staticlib`s are guaranteed to use the [`System`] by
-//! default.
-//!
-//! # The `#[global_allocator]` attribute
-//!
-//! This attribute allows configuring the choice of global allocator.
-//! You can use this to implement a completely custom global allocator
-//! to route all[^system-alloc] default allocation requests to a custom object.
-//!
-//! ```rust
-//! use std::alloc::{GlobalAlloc, System, Layout};
-//!
-//! struct MyAllocator;
-//!
-//! unsafe impl GlobalAlloc for MyAllocator {
-//!     unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
-//!         unsafe { System.alloc(layout) }
-//!     }
-//!
-//!     unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
-//!         unsafe { System.dealloc(ptr, layout) }
-//!     }
-//! }
-//!
-//! #[global_allocator]
-//! static GLOBAL: MyAllocator = MyAllocator;
-//!
-//! fn main() {
-//!     // This `Vec` will allocate memory through `GLOBAL` above
-//!     let mut v = Vec::new();
-//!     v.push(1);
-//! }
-//! ```
-//!
-//! The attribute is used on a `static` item whose type implements the
-//! [`GlobalAlloc`] trait. This type can be provided by an external library:
-//!
-//! ```rust,ignore (demonstrates crates.io usage)
-//! use jemallocator::Jemalloc;
-//!
-//! #[global_allocator]
-//! static GLOBAL: Jemalloc = Jemalloc;
-//!
-//! fn main() {}
-//! ```
-//!
-//! The `#[global_allocator]` can only be used once in a crate
-//! or its recursive dependencies.
-//!
-//! [^system-alloc]: Note that the Rust standard library internals may still
-//! directly call [`System`] when necessary (for example for the runtime
-//! support typically required to implement a global allocator, see [re-entrance] on [`GlobalAlloc`]
-//! for more details).
-//!
-//! [re-entrance]: trait.GlobalAlloc.html#re-entrance
-
-#![deny(unsafe_op_in_unsafe_fn)]
-#![stable(feature = "alloc_module", since = "1.28.0")]
-
-use core::ptr::NonNull;
-use core::sync::atomic::{AtomicBool, AtomicPtr, Ordering};
-use core::{hint, mem, ptr};
-
-#[stable(feature = "alloc_module", since = "1.28.0")]
-#[doc(inline)]
-pub use alloc_crate::alloc::*;
-
-/// The default memory allocator provided by the operating system.
-///
-/// This is based on `malloc` on Unix platforms and `HeapAlloc` on Windows,
-/// plus related functions. However, it is not valid to mix use of the backing
-/// system allocator with `System`, as this implementation may include extra
-/// work, such as to serve alignment requests greater than the alignment
-/// provided directly by the backing system allocator.
-///
-/// This type implements the [`GlobalAlloc`] trait. Currently the default
-/// global allocator is unspecified. Libraries, however, like `cdylib`s and
-/// `staticlib`s are guaranteed to use the [`System`] by default and as such
-/// work as if they had this definition:
-///
-/// ```rust
-/// use std::alloc::System;
-///
-/// #[global_allocator]
-/// static A: System = System;
-///
-/// fn main() {
-///     let a = Box::new(4); // Allocates from the system allocator.
-///     println!("{a}");
-/// }
-/// ```
-///
-/// You can also define your own wrapper around `System` if you'd like, such as
-/// keeping track of the number of all bytes allocated:
-///
-/// ```rust
-/// use std::alloc::{System, GlobalAlloc, Layout};
-/// use std::sync::atomic::{AtomicUsize, Ordering::Relaxed};
-///
-/// struct Counter;
-///
-/// static ALLOCATED: AtomicUsize = AtomicUsize::new(0);
-///
-/// unsafe impl GlobalAlloc for Counter {
-///     unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
-///         let ret = unsafe { System.alloc(layout) };
-///         if !ret.is_null() {
-///             ALLOCATED.fetch_add(layout.size(), Relaxed);
-///         }
-///         ret
-///     }
-///
-///     unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
-///         unsafe { System.dealloc(ptr, layout); }
-///         ALLOCATED.fetch_sub(layout.size(), Relaxed);
-///     }
-/// }
-///
-/// #[global_allocator]
-/// static A: Counter = Counter;
-///
-/// fn main() {
-///     println!("allocated bytes before main: {}", ALLOCATED.load(Relaxed));
-/// }
-/// ```
-///
-/// It can also be used directly to allocate memory independently of whatever
-/// global allocator has been selected for a Rust program. For example if a Rust
-/// program opts in to using jemalloc as the global allocator, `System` will
-/// still allocate memory using `malloc` and `HeapAlloc`.
-#[stable(feature = "alloc_system_type", since = "1.28.0")]
-#[derive(Debug, Default, Copy, Clone)]
-pub struct System;
-
-impl System {
-    #[inline]
-    fn alloc_impl(&self, layout: Layout, zeroed: bool) -> Result<NonNull<[u8]>, AllocError> {
-        match layout.size() {
-            0 => Ok(NonNull::slice_from_raw_parts(layout.dangling_ptr(), 0)),
-            // SAFETY: `layout` is non-zero in size,
-            size => unsafe {
-                let raw_ptr = if zeroed {
-                    GlobalAlloc::alloc_zeroed(self, layout)
-                } else {
-                    GlobalAlloc::alloc(self, layout)
-                };
-                let ptr = NonNull::new(raw_ptr).ok_or(AllocError)?;
-                Ok(NonNull::slice_from_raw_parts(ptr, size))
-            },
-        }
-    }
-
-    // SAFETY: Same as `Allocator::grow`
-    #[inline]
-    unsafe fn grow_impl(
-        &self,
-        ptr: NonNull<u8>,
-        old_layout: Layout,
-        new_layout: Layout,
-        zeroed: bool,
-    ) -> Result<NonNull<[u8]>, AllocError> {
-        debug_assert!(
-            new_layout.size() >= old_layout.size(),
-            "`new_layout.size()` must be greater than or equal to `old_layout.size()`"
-        );
-
-        match old_layout.size() {
-            0 => self.alloc_impl(new_layout, zeroed),
-
-            // SAFETY: `new_size` is non-zero as `new_size` is greater than or equal to `old_size`
-            // as required by safety conditions and the `old_size == 0` case was handled in the
-            // previous match arm. Other conditions must be upheld by the caller
-            old_size if old_layout.align() == new_layout.align() => unsafe {
-                let new_size = new_layout.size();
-
-                // `realloc` probably checks for `new_size >= old_layout.size()` or something similar.
-                hint::assert_unchecked(new_size >= old_layout.size());
-
-                let raw_ptr = GlobalAlloc::realloc(self, ptr.as_ptr(), old_layout, new_size);
-                let ptr = NonNull::new(raw_ptr).ok_or(AllocError)?;
-                if zeroed {
-                    raw_ptr.add(old_size).write_bytes(0, new_size - old_size);
-                }
-                Ok(NonNull::slice_from_raw_parts(ptr, new_size))
-            },
-
-            // SAFETY: because `new_layout.size()` must be greater than or equal to `old_size`,
-            // both the old and new memory allocation are valid for reads and writes for `old_size`
-            // bytes. Also, because the old allocation wasn't yet deallocated, it cannot overlap
-            // `new_ptr`. Thus, the call to `copy_nonoverlapping` is safe. The safety contract
-            // for `dealloc` must be upheld by the caller.
-            old_size => unsafe {
-                let new_ptr = self.alloc_impl(new_layout, zeroed)?;
-                ptr::copy_nonoverlapping(ptr.as_ptr(), new_ptr.as_mut_ptr(), old_size);
-                Allocator::deallocate(self, ptr, old_layout);
-                Ok(new_ptr)
-            },
-        }
-    }
-}
-
-// The Allocator impl checks the layout size to be non-zero and forwards to the GlobalAlloc impl,
-// which is in `std::sys::*::alloc`.
-#[unstable(feature = "allocator_api", issue = "32838")]
-unsafe impl Allocator for System {
-    #[inline]
-    fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {
-        self.alloc_impl(layout, false)
-    }
-
-    #[inline]
-    fn allocate_zeroed(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {
-        self.alloc_impl(layout, true)
-    }
-
-    #[inline]
-    unsafe fn deallocate(&self, ptr: NonNull<u8>, layout: Layout) {
-        if layout.size() != 0 {
-            // SAFETY: `layout` is non-zero in size,
-            // other conditions must be upheld by the caller
-            unsafe { GlobalAlloc::dealloc(self, ptr.as_ptr(), layout) }
-        }
-    }
-
-    #[inline]
-    unsafe fn grow(
-        &self,
-        ptr: NonNull<u8>,
-        old_layout: Layout,
-        new_layout: Layout,
-    ) -> Result<NonNull<[u8]>, AllocError> {
-        // SAFETY: all conditions must be upheld by the caller
-        unsafe { self.grow_impl(ptr, old_layout, new_layout, false) }
-    }
-
-    #[inline]
-    unsafe fn grow_zeroed(
-        &self,
-        ptr: NonNull<u8>,
-        old_layout: Layout,
-        new_layout: Layout,
-    ) -> Result<NonNull<[u8]>, AllocError> {
-        // SAFETY: all conditions must be upheld by the caller
-        unsafe { self.grow_impl(ptr, old_layout, new_layout, true) }
-    }
-
-    #[inline]
-    unsafe fn shrink(
-        &self,
-        ptr: NonNull<u8>,
-        old_layout: Layout,
-        new_layout: Layout,
-    ) -> Result<NonNull<[u8]>, AllocError> {
-        debug_assert!(
-            new_layout.size() <= old_layout.size(),
-            "`new_layout.size()` must be smaller than or equal to `old_layout.size()`"
-        );
-
-        match new_layout.size() {
-            // SAFETY: conditions must be upheld by the caller
-            0 => unsafe {
-                Allocator::deallocate(self, ptr, old_layout);
-                Ok(NonNull::slice_from_raw_parts(new_layout.dangling_ptr(), 0))
-            },
-
-            // SAFETY: `new_size` is non-zero. Other conditions must be upheld by the caller
-            new_size if old_layout.align() == new_layout.align() => unsafe {
-                // `realloc` probably checks for `new_size <= old_layout.size()` or something similar.
-                hint::assert_unchecked(new_size <= old_layout.size());
-
-                let raw_ptr = GlobalAlloc::realloc(self, ptr.as_ptr(), old_layout, new_size);
-                let ptr = NonNull::new(raw_ptr).ok_or(AllocError)?;
-                Ok(NonNull::slice_from_raw_parts(ptr, new_size))
-            },
-
-            // SAFETY: because `new_size` must be smaller than or equal to `old_layout.size()`,
-            // both the old and new memory allocation are valid for reads and writes for `new_size`
-            // bytes. Also, because the old allocation wasn't yet deallocated, it cannot overlap
-            // `new_ptr`. Thus, the call to `copy_nonoverlapping` is safe. The safety contract
-            // for `dealloc` must be upheld by the caller.
-            new_size => unsafe {
-                let new_ptr = Allocator::allocate(self, new_layout)?;
-                ptr::copy_nonoverlapping(ptr.as_ptr(), new_ptr.as_mut_ptr(), new_size);
-                Allocator::deallocate(self, ptr, old_layout);
-                Ok(new_ptr)
-            },
-        }
-    }
-}
-
-static HOOK: AtomicPtr<()> = AtomicPtr::new(ptr::null_mut());
-
-/// Registers a custom allocation error hook, replacing any that was previously registered.
-///
-/// The allocation error hook is invoked when an infallible memory allocation fails — that is,
-/// as a consequence of calling [`handle_alloc_error`] — before the runtime aborts.
-///
-/// The allocation error hook is a global resource. [`take_alloc_error_hook`] may be used to
-/// retrieve a previously registered hook and wrap or discard it.
-///
-/// # What the provided `hook` function should expect
-///
-/// The hook function is provided with a [`Layout`] struct which contains information
-/// about the allocation that failed.
-///
-/// The hook function may choose to panic or abort; in the event that it returns normally, this
-/// will cause an immediate abort.
-///
-/// Since [`take_alloc_error_hook`] is a safe function that allows retrieving the hook, the hook
-/// function must be _sound_ to call even if no memory allocations were attempted.
-///
-/// # The default hook
-///
-/// The default hook, used if [`set_alloc_error_hook`] is never called, prints a message to
-/// standard error (and then returns, causing the runtime to abort the process).
-/// Compiler options may cause it to panic instead, and the default behavior may be changed
-/// to panicking in future versions of Rust.
-///
-/// # Examples
-///
-/// ```
-/// #![feature(alloc_error_hook)]
-///
-/// use std::alloc::{Layout, set_alloc_error_hook};
-///
-/// fn custom_alloc_error_hook(layout: Layout) {
-///    panic!("memory allocation of {} bytes failed", layout.size());
-/// }
-///
-/// set_alloc_error_hook(custom_alloc_error_hook);
-/// ```
-#[unstable(feature = "alloc_error_hook", issue = "51245")]
-pub fn set_alloc_error_hook(hook: fn(Layout)) {
-    HOOK.store(hook as *mut (), Ordering::Release);
-}
-
-// /// Unregisters the current allocation error hook, returning it.
-// ///
-// /// *See also the function [`set_alloc_error_hook`].*
-// ///
-// /// If no custom hook is registered, the default hook will be returned.
-// #[unstable(feature = "alloc_error_hook", issue = "51245")]
-// pub fn take_alloc_error_hook() -> fn(Layout) {
-//     let hook = HOOK.swap(ptr::null_mut(), Ordering::Acquire);
-//     if hook.is_null() { default_alloc_error_hook } else { unsafe { mem::transmute(hook) } }
-// }
-
-// #[optimize(size)]
-// fn default_alloc_error_hook(layout: Layout) {
-//     if cfg!(panic = "immediate-abort") {
-//         return;
-//     }
-
-//     // This is the default path taken on OOM, and the only path taken on stable with std.
-//     // Crucially, it does *not* call any user-defined code, and therefore users do not have to
-//     // worry about allocation failure causing reentrancy issues. That makes it different from
-//     // the default `__rdl_alloc_error_handler` defined in alloc (i.e., the default alloc error
-//     // handler that is  called when there is no `#[alloc_error_handler]`), which triggers a
-//     // regular panic and thus can invoke a user-defined panic hook, executing arbitrary
-//     // user-defined code.
-
-//     static PREV_ALLOC_FAILURE: AtomicBool = AtomicBool::new(false);
-//     if PREV_ALLOC_FAILURE.swap(true, Ordering::Relaxed) {
-//         // Don't try to print a backtrace if a previous alloc error happened. This likely means
-//         // there is not enough memory to print a backtrace, although it could also mean that two
-//         // threads concurrently run out of memory.
-//         rtprintpanic!(
-//             "memory allocation of {} bytes failed\nskipping backtrace printing to avoid potential recursion\n",
-//             layout.size()
-//         );
-//         return;
-//     } else {
-//         rtprintpanic!("memory allocation of {} bytes failed\n", layout.size());
-//     }
-
-//     let Some(mut out) = crate::sys::stdio::panic_output() else {
-//         return;
-//     };
-
-//     // Use a lock to prevent mixed output in multithreading context.
-//     // Some platforms also require it when printing a backtrace, like `SymFromAddr` on Windows.
-//     // Make sure to not take this lock until after checking PREV_ALLOC_FAILURE to avoid deadlocks
-//     // when there is too little memory to print a backtrace.
-//     let mut lock = crate::sys::backtrace::lock();
-
-//     match crate::panic::get_backtrace_style() {
-//         Some(crate::panic::BacktraceStyle::Short) => {
-//             drop(lock.print(&mut out, crate::backtrace_rs::PrintFmt::Short))
-//         }
-//         Some(crate::panic::BacktraceStyle::Full) => {
-//             drop(lock.print(&mut out, crate::backtrace_rs::PrintFmt::Full))
-//         }
-//         Some(crate::panic::BacktraceStyle::Off) => {
-//             use crate::io::Write;
-//             let _ = writeln!(
-//                 out,
-//                 "note: run with `RUST_BACKTRACE=1` environment variable to display a \
-//                              backtrace"
-//             );
-//             if cfg!(miri) {
-//                 let _ = writeln!(
-//                     out,
-//                     "note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` \
-//                                 for the environment variable to have an effect"
-//                 );
-//             }
-//         }
-//         // If backtraces aren't supported or are forced-off, do nothing.
-//         None => {}
-//     }
-// }
-
-// #[cfg(not(test))]
-// #[doc(hidden)]
-// #[alloc_error_handler]
-// #[unstable(feature = "alloc_internals", issue = "none")]
-// pub fn rust_oom(layout: Layout) -> ! {
-//     crate::sys::backtrace::__rust_end_short_backtrace(|| {
-//         let hook = HOOK.load(Ordering::Acquire);
-//         let hook: fn(Layout) =
-//             if hook.is_null() { default_alloc_error_hook } else { unsafe { mem::transmute(hook) } };
-//         hook(layout);
-//         crate::process::abort()
-//     })
-// }
-
-#[cfg(not(test))]
-#[doc(hidden)]
-#[allow(unused_attributes)]
-#[unstable(feature = "alloc_internals", issue = "none")]
-pub mod __default_lib_allocator {
-    use super::{GlobalAlloc, Layout, System};
-    // These magic symbol names are used as a fallback for implementing the
-    // `__rust_alloc` etc symbols (see `src/liballoc/alloc.rs`) when there is
-    // no `#[global_allocator]` attribute.
-
-    // for symbol names src/librustc_ast/expand/allocator.rs
-    // for signatures src/librustc_allocator/lib.rs
-
-    // linkage directives are provided as part of the current compiler allocator
-    // ABI
-
-    #[rustc_std_internal_symbol]
-    pub unsafe extern "C" fn __rdl_alloc(size: usize, align: usize) -> *mut u8 {
-        // SAFETY: see the guarantees expected by `Layout::from_size_align` and
-        // `GlobalAlloc::alloc`.
-        unsafe {
-            let layout = Layout::from_size_align_unchecked(size, align);
-            System.alloc(layout)
-        }
-    }
-
-    #[rustc_std_internal_symbol]
-    pub unsafe extern "C" fn __rdl_dealloc(ptr: *mut u8, size: usize, align: usize) {
-        // SAFETY: see the guarantees expected by `Layout::from_size_align` and
-        // `GlobalAlloc::dealloc`.
-        unsafe { System.dealloc(ptr, Layout::from_size_align_unchecked(size, align)) }
-    }
-
-    #[rustc_std_internal_symbol]
-    pub unsafe extern "C" fn __rdl_realloc(
-        ptr: *mut u8,
-        old_size: usize,
-        align: usize,
-        new_size: usize,
-    ) -> *mut u8 {
-        // SAFETY: see the guarantees expected by `Layout::from_size_align` and
-        // `GlobalAlloc::realloc`.
-        unsafe {
-            let old_layout = Layout::from_size_align_unchecked(old_size, align);
-            System.realloc(ptr, old_layout, new_size)
-        }
-    }
-
-    #[rustc_std_internal_symbol]
-    pub unsafe extern "C" fn __rdl_alloc_zeroed(size: usize, align: usize) -> *mut u8 {
-        // SAFETY: see the guarantees expected by `Layout::from_size_align` and
-        // `GlobalAlloc::alloc_zeroed`.
-        unsafe {
-            let layout = Layout::from_size_align_unchecked(size, align);
-            System.alloc_zeroed(layout)
-        }
-    }
-}

crates/std/src/error.rs

@@ -1,4 +0,0 @@
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use core::error::Error;
-#[unstable(feature = "error_generic_member_access", issue = "99301")]
-pub use core::error::{Request, request_ref, request_value};

crates/std/src/ffi/c_str.rs

@@ -1,14 +0,0 @@
-//! [`CStr`], [`CString`], and related types.
-
-#[stable(feature = "cstring_from_vec_with_nul", since = "1.58.0")]
-pub use alloc_crate::ffi::c_str::FromVecWithNulError;
-#[stable(feature = "cstring_into", since = "1.7.0")]
-pub use alloc_crate::ffi::c_str::IntoStringError;
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use alloc_crate::ffi::c_str::{CString, NulError};
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use core::ffi::c_str::CStr;
-#[stable(feature = "cstr_from_bytes_until_nul", since = "1.69.0")]
-pub use core::ffi::c_str::FromBytesUntilNulError;
-#[stable(feature = "cstr_from_bytes", since = "1.10.0")]
-pub use core::ffi::c_str::FromBytesWithNulError;

crates/std/src/ffi/mod.rs

@@ -1,207 +0,0 @@
-//! Utilities related to FFI bindings.
-//!
-//! This module provides utilities to handle data across non-Rust
-//! interfaces, like other programming languages and the underlying
-//! operating system. It is mainly of use for FFI (Foreign Function
-//! Interface) bindings and code that needs to exchange C-like strings
-//! with other languages.
-//!
-//! # Overview
-//!
-//! Rust represents owned strings with the [`String`] type, and
-//! borrowed slices of strings with the [`str`] primitive. Both are
-//! always in UTF-8 encoding, and may contain nul bytes in the middle,
-//! i.e., if you look at the bytes that make up the string, there may
-//! be a `\0` among them. Both `String` and `str` store their length
-//! explicitly; there are no nul terminators at the end of strings
-//! like in C.
-//!
-//! C strings are different from Rust strings:
-//!
-//! * **Encodings** - Rust strings are UTF-8, but C strings may use
-//! other encodings. If you are using a string from C, you should
-//! check its encoding explicitly, rather than just assuming that it
-//! is UTF-8 like you can do in Rust.
-//!
-//! * **Character size** - C strings may use `char` or `wchar_t`-sized
-//! characters; please **note** that C's `char` is different from Rust's.
-//! The C standard leaves the actual sizes of those types open to
-//! interpretation, but defines different APIs for strings made up of
-//! each character type. Rust strings are always UTF-8, so different
-//! Unicode characters will be encoded in a variable number of bytes
-//! each. The Rust type [`char`] represents a '[Unicode scalar
-//! value]', which is similar to, but not the same as, a '[Unicode
-//! code point]'.
-//!
-//! * **Nul terminators and implicit string lengths** - Often, C
-//! strings are nul-terminated, i.e., they have a `\0` character at the
-//! end. The length of a string buffer is not stored, but has to be
-//! calculated; to compute the length of a string, C code must
-//! manually call a function like `strlen()` for `char`-based strings,
-//! or `wcslen()` for `wchar_t`-based ones. Those functions return
-//! the number of characters in the string excluding the nul
-//! terminator, so the buffer length is really `len+1` characters.
-//! Rust strings don't have a nul terminator; their length is always
-//! stored and does not need to be calculated. While in Rust
-//! accessing a string's length is an *O*(1) operation (because the
-//! length is stored); in C it is an *O*(*n*) operation because the
-//! length needs to be computed by scanning the string for the nul
-//! terminator.
-//!
-//! * **Internal nul characters** - When C strings have a nul
-//! terminator character, this usually means that they cannot have nul
-//! characters in the middle — a nul character would essentially
-//! truncate the string. Rust strings *can* have nul characters in
-//! the middle, because nul does not have to mark the end of the
-//! string in Rust.
-//!
-//! # Representations of non-Rust strings
-//!
-//! [`CString`] and [`CStr`] are useful when you need to transfer
-//! UTF-8 strings to and from languages with a C ABI, like Python.
-//!
-//! * **From Rust to C:** [`CString`] represents an owned, C-friendly
-//! string: it is nul-terminated, and has no internal nul characters.
-//! Rust code can create a [`CString`] out of a normal string (provided
-//! that the string doesn't have nul characters in the middle), and
-//! then use a variety of methods to obtain a raw <code>\*mut [u8]</code> that can
-//! then be passed as an argument to functions which use the C
-//! conventions for strings.
-//!
-//! * **From C to Rust:** [`CStr`] represents a borrowed C string; it
-//! is what you would use to wrap a raw <code>\*const [u8]</code> that you got from
-//! a C function. A [`CStr`] is guaranteed to be a nul-terminated array
-//! of bytes. Once you have a [`CStr`], you can convert it to a Rust
-//! <code>&[str]</code> if it's valid UTF-8, or lossily convert it by adding
-//! replacement characters.
-//!
-//! [`OsString`] and [`OsStr`] are useful when you need to transfer
-//! strings to and from the operating system itself, or when capturing
-//! the output of external commands. Conversions between [`OsString`],
-//! [`OsStr`] and Rust strings work similarly to those for [`CString`]
-//! and [`CStr`].
-//!
-//! * [`OsString`] losslessly represents an owned platform string. However, this
-//! representation is not necessarily in a form native to the platform.
-//! In the Rust standard library, various APIs that transfer strings to/from the operating
-//! system use [`OsString`] instead of plain strings. For example,
-//! [`env::var_os()`] is used to query environment variables; it
-//! returns an <code>[Option]<[OsString]></code>. If the environment variable
-//! exists you will get a <code>[Some]\(os_string)</code>, which you can
-//! *then* try to convert to a Rust string. This yields a [`Result`], so that
-//! your code can detect errors in case the environment variable did
-//! not in fact contain valid Unicode data.
-//!
-//! * [`OsStr`] losslessly represents a borrowed reference to a platform string.
-//! However, this representation is not necessarily in a form native to the platform.
-//! It can be converted into a UTF-8 Rust string slice in a similar way to
-//! [`OsString`].
-//!
-//! # Conversions
-//!
-//! ## On Unix
-//!
-//! On Unix, [`OsStr`] implements the
-//! <code>std::os::unix::ffi::[OsStrExt][unix.OsStrExt]</code> trait, which
-//! augments it with two methods, [`from_bytes`] and [`as_bytes`].
-//! These do inexpensive conversions from and to byte slices.
-//!
-//! Additionally, on Unix [`OsString`] implements the
-//! <code>std::os::unix::ffi::[OsStringExt][unix.OsStringExt]</code> trait,
-//! which provides [`from_vec`] and [`into_vec`] methods that consume
-//! their arguments, and take or produce vectors of [`u8`].
-//!
-//! ## On Windows
-//!
-//! An [`OsStr`] can be losslessly converted to a native Windows string. And
-//! a native Windows string can be losslessly converted to an [`OsString`].
-//!
-//! On Windows, [`OsStr`] implements the
-//! <code>std::os::windows::ffi::[OsStrExt][windows.OsStrExt]</code> trait,
-//! which provides an [`encode_wide`] method. This provides an
-//! iterator that can be [`collect`]ed into a vector of [`u16`]. After a nul
-//! characters is appended, this is the same as a native Windows string.
-//!
-//! Additionally, on Windows [`OsString`] implements the
-//! <code>std::os::windows:ffi::[OsStringExt][windows.OsStringExt]</code>
-//! trait, which provides a [`from_wide`] method to convert a native Windows
-//! string (without the terminating nul character) to an [`OsString`].
-//!
-//! ## Other platforms
-//!
-//! Many other platforms provide their own extension traits in a
-//! `std::os::*::ffi` module.
-//!
-//! ## On all platforms
-//!
-//! On all platforms, [`OsStr`] consists of a sequence of bytes that is encoded as a superset of
-//! UTF-8; see [`OsString`] for more details on its encoding on different platforms.
-//!
-//! For limited, inexpensive conversions from and to bytes, see [`OsStr::as_encoded_bytes`] and
-//! [`OsStr::from_encoded_bytes_unchecked`].
-//!
-//! For basic string processing, see [`OsStr::slice_encoded_bytes`].
-//!
-//! [Unicode scalar value]: https://www.unicode.org/glossary/#unicode_scalar_value
-//! [Unicode code point]: https://www.unicode.org/glossary/#code_point
-//! [`env::set_var()`]: crate::env::set_var "env::set_var"
-//! [`env::var_os()`]: crate::env::var_os "env::var_os"
-//! [unix.OsStringExt]: crate::os::unix::ffi::OsStringExt "os::unix::ffi::OsStringExt"
-//! [`from_vec`]: crate::os::unix::ffi::OsStringExt::from_vec "os::unix::ffi::OsStringExt::from_vec"
-//! [`into_vec`]: crate::os::unix::ffi::OsStringExt::into_vec "os::unix::ffi::OsStringExt::into_vec"
-//! [unix.OsStrExt]: crate::os::unix::ffi::OsStrExt "os::unix::ffi::OsStrExt"
-//! [`from_bytes`]: crate::os::unix::ffi::OsStrExt::from_bytes "os::unix::ffi::OsStrExt::from_bytes"
-//! [`as_bytes`]: crate::os::unix::ffi::OsStrExt::as_bytes "os::unix::ffi::OsStrExt::as_bytes"
-//! [`OsStrExt`]: crate::os::unix::ffi::OsStrExt "os::unix::ffi::OsStrExt"
-//! [windows.OsStrExt]: crate::os::windows::ffi::OsStrExt "os::windows::ffi::OsStrExt"
-//! [`encode_wide`]: crate::os::windows::ffi::OsStrExt::encode_wide "os::windows::ffi::OsStrExt::encode_wide"
-//! [`collect`]: crate::iter::Iterator::collect "iter::Iterator::collect"
-//! [windows.OsStringExt]: crate::os::windows::ffi::OsStringExt "os::windows::ffi::OsStringExt"
-//! [`from_wide`]: crate::os::windows::ffi::OsStringExt::from_wide "os::windows::ffi::OsStringExt::from_wide"
-
-#![stable(feature = "rust1", since = "1.0.0")]
-
-#[stable(feature = "c_str_module", since = "1.88.0")]
-pub mod c_str;
-
-#[stable(feature = "core_c_void", since = "1.30.0")]
-pub use core::ffi::c_void;
-#[unstable(
-    feature = "c_variadic",
-    reason = "the `c_variadic` feature has not been properly tested on \
-              all supported platforms",
-    issue = "44930"
-)]
-pub use core::ffi::{VaArgSafe, VaList};
-#[stable(feature = "core_ffi_c", since = "1.64.0")]
-pub use core::ffi::{
-    c_char, c_double, c_float, c_int, c_long, c_longlong, c_schar, c_short, c_uchar, c_uint,
-    c_ulong, c_ulonglong, c_ushort,
-};
-#[unstable(feature = "c_size_t", issue = "88345")]
-pub use core::ffi::{c_ptrdiff_t, c_size_t, c_ssize_t};
-
-#[doc(inline)]
-#[stable(feature = "cstr_from_bytes_until_nul", since = "1.69.0")]
-pub use self::c_str::FromBytesUntilNulError;
-#[doc(inline)]
-#[stable(feature = "cstr_from_bytes", since = "1.10.0")]
-pub use self::c_str::FromBytesWithNulError;
-#[doc(inline)]
-#[stable(feature = "cstring_from_vec_with_nul", since = "1.58.0")]
-pub use self::c_str::FromVecWithNulError;
-#[doc(inline)]
-#[stable(feature = "cstring_into", since = "1.7.0")]
-pub use self::c_str::IntoStringError;
-#[doc(inline)]
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use self::c_str::NulError;
-#[doc(inline)]
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use self::c_str::{CStr, CString};
-#[stable(feature = "rust1", since = "1.0.0")]
-#[doc(inline)]
-pub use self::os_str::{OsStr, OsString};
-
-#[stable(feature = "os_str_display", since = "1.87.0")]
-pub mod os_str;

crates/std/src/ffi/os_str/tests.rs

@@ -1,311 +0,0 @@
-use super::*;
-use crate::mem::MaybeUninit;
-use crate::ptr;
-
-#[test]
-fn test_os_string_with_capacity() {
-    let os_string = OsString::with_capacity(0);
-    assert_eq!(0, os_string.inner.into_inner().capacity());
-
-    let os_string = OsString::with_capacity(10);
-    assert_eq!(10, os_string.inner.into_inner().capacity());
-
-    let mut os_string = OsString::with_capacity(0);
-    os_string.push("abc");
-    assert!(os_string.inner.into_inner().capacity() >= 3);
-}
-
-#[test]
-fn test_os_string_clear() {
-    let mut os_string = OsString::from("abc");
-    assert_eq!(3, os_string.inner.as_inner().len());
-
-    os_string.clear();
-    assert_eq!(&os_string, "");
-    assert_eq!(0, os_string.inner.as_inner().len());
-}
-
-#[test]
-fn test_os_string_leak() {
-    let os_string = OsString::from("have a cake");
-    let (len, cap) = (os_string.len(), os_string.capacity());
-    let leaked = os_string.leak();
-    assert_eq!(leaked.as_encoded_bytes(), b"have a cake");
-    unsafe { drop(String::from_raw_parts(leaked as *mut OsStr as _, len, cap)) }
-}
-
-#[test]
-fn test_os_string_capacity() {
-    let os_string = OsString::with_capacity(0);
-    assert_eq!(0, os_string.capacity());
-
-    let os_string = OsString::with_capacity(10);
-    assert_eq!(10, os_string.capacity());
-
-    let mut os_string = OsString::with_capacity(0);
-    os_string.push("abc");
-    assert!(os_string.capacity() >= 3);
-}
-
-#[test]
-fn test_os_string_reserve() {
-    let mut os_string = OsString::new();
-    assert_eq!(os_string.capacity(), 0);
-
-    os_string.reserve(2);
-    assert!(os_string.capacity() >= 2);
-
-    for _ in 0..16 {
-        os_string.push("a");
-    }
-
-    assert!(os_string.capacity() >= 16);
-    os_string.reserve(16);
-    assert!(os_string.capacity() >= 32);
-
-    os_string.push("a");
-
-    os_string.reserve(16);
-    assert!(os_string.capacity() >= 33)
-}
-
-#[test]
-fn test_os_string_reserve_exact() {
-    let mut os_string = OsString::new();
-    assert_eq!(os_string.capacity(), 0);
-
-    os_string.reserve_exact(2);
-    assert!(os_string.capacity() >= 2);
-
-    for _ in 0..16 {
-        os_string.push("a");
-    }
-
-    assert!(os_string.capacity() >= 16);
-    os_string.reserve_exact(16);
-    assert!(os_string.capacity() >= 32);
-
-    os_string.push("a");
-
-    os_string.reserve_exact(16);
-    assert!(os_string.capacity() >= 33)
-}
-
-#[test]
-fn test_os_string_join() {
-    let strings = [OsStr::new("hello"), OsStr::new("dear"), OsStr::new("world")];
-    assert_eq!("hello", strings[..1].join(OsStr::new(" ")));
-    assert_eq!("hello dear world", strings.join(OsStr::new(" ")));
-    assert_eq!("hellodearworld", strings.join(OsStr::new("")));
-    assert_eq!("hello.\n dear.\n world", strings.join(OsStr::new(".\n ")));
-
-    assert_eq!("dear world", strings[1..].join(&OsString::from(" ")));
-
-    let strings_abc = [OsString::from("a"), OsString::from("b"), OsString::from("c")];
-    assert_eq!("a b c", strings_abc.join(OsStr::new(" ")));
-}
-
-#[test]
-fn test_os_string_default() {
-    let os_string: OsString = Default::default();
-    assert_eq!("", &os_string);
-}
-
-#[test]
-fn test_os_str_is_empty() {
-    let mut os_string = OsString::new();
-    assert!(os_string.is_empty());
-
-    os_string.push("abc");
-    assert!(!os_string.is_empty());
-
-    os_string.clear();
-    assert!(os_string.is_empty());
-}
-
-#[test]
-fn test_os_str_len() {
-    let mut os_string = OsString::new();
-    assert_eq!(0, os_string.len());
-
-    os_string.push("abc");
-    assert_eq!(3, os_string.len());
-
-    os_string.clear();
-    assert_eq!(0, os_string.len());
-}
-
-#[test]
-fn test_os_str_default() {
-    let os_str: &OsStr = Default::default();
-    assert_eq!("", os_str);
-}
-
-#[test]
-fn into_boxed() {
-    let orig = "Hello, world!";
-    let os_str = OsStr::new(orig);
-    let boxed: Box<OsStr> = Box::from(os_str);
-    let os_string = os_str.to_owned().into_boxed_os_str().into_os_string();
-    assert_eq!(os_str, &*boxed);
-    assert_eq!(&*boxed, &*os_string);
-    assert_eq!(&*os_string, os_str);
-}
-
-#[test]
-fn boxed_default() {
-    let boxed = <Box<OsStr>>::default();
-    assert!(boxed.is_empty());
-}
-
-#[test]
-fn test_os_str_clone_into() {
-    let mut os_string = OsString::with_capacity(123);
-    os_string.push("hello");
-    let os_str = OsStr::new("bonjour");
-    os_str.clone_into(&mut os_string);
-    assert_eq!(os_str, os_string);
-    assert!(os_string.capacity() >= 123);
-}
-
-#[test]
-fn into_rc() {
-    let orig = "Hello, world!";
-    let os_str = OsStr::new(orig);
-    let rc: Rc<OsStr> = Rc::from(os_str);
-    let arc: Arc<OsStr> = Arc::from(os_str);
-
-    assert_eq!(&*rc, os_str);
-    assert_eq!(&*arc, os_str);
-
-    let rc2: Rc<OsStr> = Rc::from(os_str.to_owned());
-    let arc2: Arc<OsStr> = Arc::from(os_str.to_owned());
-
-    assert_eq!(&*rc2, os_str);
-    assert_eq!(&*arc2, os_str);
-}
-
-#[test]
-fn slice_encoded_bytes() {
-    let os_str = OsStr::new("123θგ🦀");
-    // ASCII
-    let digits = os_str.slice_encoded_bytes(..3);
-    assert_eq!(digits, "123");
-    let three = os_str.slice_encoded_bytes(2..3);
-    assert_eq!(three, "3");
-    // 2-byte UTF-8
-    let theta = os_str.slice_encoded_bytes(3..5);
-    assert_eq!(theta, "θ");
-    // 3-byte UTF-8
-    let gani = os_str.slice_encoded_bytes(5..8);
-    assert_eq!(gani, "გ");
-    // 4-byte UTF-8
-    let crab = os_str.slice_encoded_bytes(8..);
-    assert_eq!(crab, "🦀");
-}
-
-#[test]
-#[should_panic]
-fn slice_out_of_bounds() {
-    let crab = OsStr::new("🦀");
-    let _ = crab.slice_encoded_bytes(..5);
-}
-
-#[test]
-#[should_panic]
-fn slice_mid_char() {
-    let crab = OsStr::new("🦀");
-    let _ = crab.slice_encoded_bytes(..2);
-}
-
-#[cfg(unix)]
-#[test]
-#[should_panic(expected = "byte index 1 is not an OsStr boundary")]
-fn slice_invalid_data() {
-    use crate::os::unix::ffi::OsStrExt;
-
-    let os_string = OsStr::from_bytes(b"\xFF\xFF");
-    let _ = os_string.slice_encoded_bytes(1..);
-}
-
-#[cfg(unix)]
-#[test]
-#[should_panic(expected = "byte index 1 is not an OsStr boundary")]
-fn slice_partial_utf8() {
-    use crate::os::unix::ffi::{OsStrExt, OsStringExt};
-
-    let part_crab = OsStr::from_bytes(&"🦀".as_bytes()[..3]);
-    let mut os_string = OsString::from_vec(vec![0xFF]);
-    os_string.push(part_crab);
-    let _ = os_string.slice_encoded_bytes(1..);
-}
-
-#[cfg(unix)]
-#[test]
-fn slice_invalid_edge() {
-    use crate::os::unix::ffi::{OsStrExt, OsStringExt};
-
-    let os_string = OsStr::from_bytes(b"a\xFFa");
-    assert_eq!(os_string.slice_encoded_bytes(..1), "a");
-    assert_eq!(os_string.slice_encoded_bytes(1..), OsStr::from_bytes(b"\xFFa"));
-    assert_eq!(os_string.slice_encoded_bytes(..2), OsStr::from_bytes(b"a\xFF"));
-    assert_eq!(os_string.slice_encoded_bytes(2..), "a");
-
-    let os_string = OsStr::from_bytes(&"abc🦀".as_bytes()[..6]);
-    assert_eq!(os_string.slice_encoded_bytes(..3), "abc");
-    assert_eq!(os_string.slice_encoded_bytes(3..), OsStr::from_bytes(b"\xF0\x9F\xA6"));
-
-    let mut os_string = OsString::from_vec(vec![0xFF]);
-    os_string.push("🦀");
-    assert_eq!(os_string.slice_encoded_bytes(..1), OsStr::from_bytes(b"\xFF"));
-    assert_eq!(os_string.slice_encoded_bytes(1..), "🦀");
-}
-
-#[cfg(windows)]
-#[test]
-#[should_panic(expected = "byte index 3 lies between surrogate codepoints")]
-fn slice_between_surrogates() {
-    use crate::os::windows::ffi::OsStringExt;
-
-    let os_string = OsString::from_wide(&[0xD800, 0xD800]);
-    assert_eq!(os_string.as_encoded_bytes(), &[0xED, 0xA0, 0x80, 0xED, 0xA0, 0x80]);
-    let _ = os_string.slice_encoded_bytes(..3);
-}
-
-#[cfg(windows)]
-#[test]
-fn slice_surrogate_edge() {
-    use crate::os::windows::ffi::OsStringExt;
-
-    let surrogate = OsString::from_wide(&[0xD800]);
-    let mut pre_crab = surrogate.clone();
-    pre_crab.push("🦀");
-    assert_eq!(pre_crab.slice_encoded_bytes(..3), surrogate);
-    assert_eq!(pre_crab.slice_encoded_bytes(3..), "🦀");
-
-    let mut post_crab = OsString::from("🦀");
-    post_crab.push(&surrogate);
-    assert_eq!(post_crab.slice_encoded_bytes(..4), "🦀");
-    assert_eq!(post_crab.slice_encoded_bytes(4..), surrogate);
-}
-
-#[test]
-fn clone_to_uninit() {
-    let a = OsStr::new("hello.txt");
-
-    let mut storage = vec![MaybeUninit::<u8>::uninit(); size_of_val::<OsStr>(a)];
-    unsafe { a.clone_to_uninit(ptr::from_mut::<[_]>(storage.as_mut_slice()).cast()) };
-    assert_eq!(a.as_encoded_bytes(), unsafe { storage.assume_init_ref() });
-
-    let mut b: Box<OsStr> = OsStr::new("world.exe").into();
-    assert_eq!(size_of_val::<OsStr>(a), size_of_val::<OsStr>(&b));
-    assert_ne!(a, &*b);
-    unsafe { a.clone_to_uninit(ptr::from_mut::<OsStr>(&mut b).cast()) };
-    assert_eq!(a, &*b);
-}
-
-#[test]
-fn debug() {
-    let s = "'single quotes'";
-    assert_eq!(format!("{:?}", OsStr::new(s)), format!("{:?}", s));
-}

crates/std/src/hash/mod.rs

@@ -1,91 +0,0 @@
-//! Generic hashing support.
-//!
-//! This module provides a generic way to compute the [hash] of a value.
-//! Hashes are most commonly used with [`HashMap`] and [`HashSet`].
-//!
-//! [hash]: https://en.wikipedia.org/wiki/Hash_function
-//! [`HashMap`]: ../../std/collections/struct.HashMap.html
-//! [`HashSet`]: ../../std/collections/struct.HashSet.html
-//!
-//! The simplest way to make a type hashable is to use `#[derive(Hash)]`:
-//!
-//! # Examples
-//!
-//! ```rust
-//! use std::hash::{DefaultHasher, Hash, Hasher};
-//!
-//! #[derive(Hash)]
-//! struct Person {
-//!     id: u32,
-//!     name: String,
-//!     phone: u64,
-//! }
-//!
-//! let person1 = Person {
-//!     id: 5,
-//!     name: "Janet".to_string(),
-//!     phone: 555_666_7777,
-//! };
-//! let person2 = Person {
-//!     id: 5,
-//!     name: "Bob".to_string(),
-//!     phone: 555_666_7777,
-//! };
-//!
-//! assert!(calculate_hash(&person1) != calculate_hash(&person2));
-//!
-//! fn calculate_hash<T: Hash>(t: &T) -> u64 {
-//!     let mut s = DefaultHasher::new();
-//!     t.hash(&mut s);
-//!     s.finish()
-//! }
-//! ```
-//!
-//! If you need more control over how a value is hashed, you need to implement
-//! the [`Hash`] trait:
-//!
-//! ```rust
-//! use std::hash::{DefaultHasher, Hash, Hasher};
-//!
-//! struct Person {
-//!     id: u32,
-//!     # #[allow(dead_code)]
-//!     name: String,
-//!     phone: u64,
-//! }
-//!
-//! impl Hash for Person {
-//!     fn hash<H: Hasher>(&self, state: &mut H) {
-//!         self.id.hash(state);
-//!         self.phone.hash(state);
-//!     }
-//! }
-//!
-//! let person1 = Person {
-//!     id: 5,
-//!     name: "Janet".to_string(),
-//!     phone: 555_666_7777,
-//! };
-//! let person2 = Person {
-//!     id: 5,
-//!     name: "Bob".to_string(),
-//!     phone: 555_666_7777,
-//! };
-//!
-//! assert_eq!(calculate_hash(&person1), calculate_hash(&person2));
-//!
-//! fn calculate_hash<T: Hash>(t: &T) -> u64 {
-//!     let mut s = DefaultHasher::new();
-//!     t.hash(&mut s);
-//!     s.finish()
-//! }
-//! ```
-#![stable(feature = "rust1", since = "1.0.0")]
-
-pub(crate) mod random;
-
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use core::hash::*;
-
-#[stable(feature = "std_hash_exports", since = "1.76.0")]
-pub use self::random::{DefaultHasher, RandomState};

crates/std/src/hash/random.rs

@@ -1,159 +0,0 @@
-//! This module exists to isolate [`RandomState`] and [`DefaultHasher`] outside of the
-//! [`collections`] module without actually publicly exporting them, so that parts of that
-//! implementation can more easily be moved to the [`alloc`] crate.
-//!
-//! Although its items are public and contain stability attributes, they can't actually be accessed
-//! outside this crate.
-//!
-//! [`collections`]: crate::collections
-
-use super::{BuildHasher, Hasher, SipHasher13};
-use crate::cell::Cell;
-use crate::fmt;
-use crate::sys::random::hashmap_random_keys;
-
-/// `RandomState` is the default state for [`HashMap`] types.
-///
-/// A particular instance `RandomState` will create the same instances of
-/// [`Hasher`], but the hashers created by two different `RandomState`
-/// instances are unlikely to produce the same result for the same values.
-///
-/// [`HashMap`]: crate::collections::HashMap
-///
-/// # Examples
-///
-/// ```
-/// use std::collections::HashMap;
-/// use std::hash::RandomState;
-///
-/// let s = RandomState::new();
-/// let mut map = HashMap::with_hasher(s);
-/// map.insert(1, 2);
-/// ```
-#[stable(feature = "hashmap_build_hasher", since = "1.7.0")]
-#[derive(Clone)]
-pub struct RandomState {
-    k0: u64,
-    k1: u64,
-}
-
-impl RandomState {
-    /// Constructs a new `RandomState` that is initialized with random keys.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::hash::RandomState;
-    ///
-    /// let s = RandomState::new();
-    /// ```
-    #[inline]
-    #[allow(deprecated)]
-    // rand
-    #[must_use]
-    #[stable(feature = "hashmap_build_hasher", since = "1.7.0")]
-    pub fn new() -> RandomState {
-        // Historically this function did not cache keys from the OS and instead
-        // simply always called `rand::thread_rng().gen()` twice. In #31356 it
-        // was discovered, however, that because we re-seed the thread-local RNG
-        // from the OS periodically that this can cause excessive slowdown when
-        // many hash maps are created on a thread. To solve this performance
-        // trap we cache the first set of randomly generated keys per-thread.
-        //
-        // Later in #36481 it was discovered that exposing a deterministic
-        // iteration order allows a form of DOS attack. To counter that we
-        // increment one of the seeds on every RandomState creation, giving
-        // every corresponding HashMap a different iteration order.
-        thread_local!(static KEYS: Cell<(u64, u64)> = {
-            Cell::new(hashmap_random_keys())
-        });
-
-        KEYS.with(|keys| {
-            let (k0, k1) = keys.get();
-            keys.set((k0.wrapping_add(1), k1));
-            RandomState { k0, k1 }
-        })
-    }
-}
-
-#[stable(feature = "hashmap_build_hasher", since = "1.7.0")]
-impl BuildHasher for RandomState {
-    type Hasher = DefaultHasher;
-    #[inline]
-    fn build_hasher(&self) -> DefaultHasher {
-        DefaultHasher(SipHasher13::new_with_keys(self.k0, self.k1))
-    }
-}
-
-/// The default [`Hasher`] used by [`RandomState`].
-///
-/// The internal algorithm is not specified, and so it and its hashes should
-/// not be relied upon over releases.
-#[derive(Clone, Debug)]
-#[stable(feature = "hashmap_build_hasher", since = "1.7.0")]
-pub struct DefaultHasher(SipHasher13);
-
-impl DefaultHasher {
-    /// Creates a new `DefaultHasher`.
-    ///
-    /// This hasher is not guaranteed to be the same as all other
-    /// `DefaultHasher` instances, but is the same as all other `DefaultHasher`
-    /// instances created through `new` or `default`.
-    #[stable(feature = "hashmap_default_hasher", since = "1.13.0")]
-    #[inline]
-    #[rustc_const_unstable(feature = "const_default", issue = "143894")]
-    #[must_use]
-    pub const fn new() -> DefaultHasher {
-        DefaultHasher(SipHasher13::new_with_keys(0, 0))
-    }
-}
-
-#[stable(feature = "hashmap_default_hasher", since = "1.13.0")]
-#[rustc_const_unstable(feature = "const_default", issue = "143894")]
-impl const Default for DefaultHasher {
-    /// Creates a new `DefaultHasher` using [`new`].
-    /// See its documentation for more.
-    ///
-    /// [`new`]: DefaultHasher::new
-    #[inline]
-    fn default() -> DefaultHasher {
-        DefaultHasher::new()
-    }
-}
-
-#[stable(feature = "hashmap_default_hasher", since = "1.13.0")]
-impl Hasher for DefaultHasher {
-    // The underlying `SipHasher13` doesn't override the other
-    // `write_*` methods, so it's ok not to forward them here.
-
-    #[inline]
-    fn write(&mut self, msg: &[u8]) {
-        self.0.write(msg)
-    }
-
-    #[inline]
-    fn write_str(&mut self, s: &str) {
-        self.0.write_str(s);
-    }
-
-    #[inline]
-    fn finish(&self) -> u64 {
-        self.0.finish()
-    }
-}
-
-#[stable(feature = "hashmap_build_hasher", since = "1.7.0")]
-impl Default for RandomState {
-    /// Constructs a new `RandomState`.
-    #[inline]
-    fn default() -> RandomState {
-        RandomState::new()
-    }
-}
-
-#[stable(feature = "std_debug", since = "1.16.0")]
-impl fmt::Debug for RandomState {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("RandomState").finish_non_exhaustive()
-    }
-}

crates/std/src/io.rs

@@ -1,71 +0,0 @@
-use crate::fs::File;
-use io::IoBase;
-pub use io::Read;
-pub use io::Seek;
-pub use io::SeekFrom;
-pub use io::Write;
-
-pub struct Stdin;
-
-impl IoBase for Stdin {
-    type Error = ();
-}
-
-impl Read for Stdin {
-    fn read(&mut self, buf: &mut [u8]) -> core::result::Result<usize, Self::Error> {
-        unsafe { File::from_raw_fd(0).read(buf) }
-    }
-}
-
-pub fn stdin() -> Stdin {
-    Stdin
-}
-
-pub type Result<T> = core::result::Result<T, Error>;
-
-pub(super) struct Repr();
-
-// Part took from the real std
-#[rustc_macro_transparency = "semiopaque"]
-#[unstable(feature = "io_const_error", issue = "133448")]
-#[allow_internal_unstable(hint_must_use, io_const_error_internals)]
-pub macro const_error($kind:expr, $message:expr $(,)?) {
-    crate::io::Error::new()
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-pub struct Error {
-    repr: Repr,
-}
-
-impl Error {
-    pub const fn new() -> Self {
-        Self { repr: Repr() }
-    }
-}
-
-#[allow(dead_code)]
-impl Error {
-    pub(crate) const INVALID_UTF8: Self =
-        const_error!(ErrorKind::InvalidData, "stream did not contain valid UTF-8");
-
-    pub(crate) const READ_EXACT_EOF: Self =
-        const_error!(ErrorKind::UnexpectedEof, "failed to fill whole buffer");
-
-    pub(crate) const UNKNOWN_THREAD_COUNT: Self = const_error!(
-        ErrorKind::NotFound,
-        "the number of hardware threads is not known for the target platform",
-    );
-
-    pub(crate) const UNSUPPORTED_PLATFORM: Self =
-        const_error!(ErrorKind::Unsupported, "operation not supported on this platform");
-
-    pub(crate) const WRITE_ALL_EOF: Self =
-        const_error!(ErrorKind::WriteZero, "failed to write whole buffer");
-
-    pub(crate) const ZERO_TIMEOUT: Self =
-        const_error!(ErrorKind::InvalidInput, "cannot set a 0 duration timeout");
-
-    pub(crate) const NO_ADDRESSES: Self =
-        const_error!(ErrorKind::InvalidInput, "could not resolve to any addresses");
-}

crates/std/src/lib.rs

@@ -1,314 +0,0 @@
-#![unstable(feature = "custom_std", issue = "none")]
-#![no_std]
-//
-// Lints:
-#![warn(deprecated_in_future)]
-// #![warn(missing_docs)]
-// #![warn(missing_debug_implementations)]
-#![allow(explicit_outlives_requirements)]
-#![allow(unused_lifetimes)]
-#![allow(internal_features)]
-#![deny(fuzzy_provenance_casts)]
-#![deny(unsafe_op_in_unsafe_fn)]
-#![allow(rustdoc::redundant_explicit_links)]
-#![warn(rustdoc::unescaped_backticks)]
-// Ensure that std can be linked against panic_abort despite compiled with `-C panic=unwind`
-#![deny(ffi_unwind_calls)]
-// std may use features in a platform-specific way
-#![allow(unused_features)]
-//
-// Features:
-#![cfg_attr(
-    test,
-    feature(internal_output_capture, print_internals, update_panic_count, rt)
-)]
-#![cfg_attr(
-    all(target_vendor = "fortanix", target_env = "sgx"),
-    feature(slice_index_methods, coerce_unsized, sgx_platform)
-)]
-#![cfg_attr(all(test, target_os = "uefi"), feature(uefi_std))]
-#![cfg_attr(target_family = "wasm", feature(stdarch_wasm_atomic_wait))]
-#![cfg_attr(target_arch = "wasm64", feature(simd_wasm64))]
-//
-// Language features:
-// tidy-alphabetical-start
-#![feature(alloc_error_handler)]
-#![feature(allocator_internals)]
-#![feature(allow_internal_unsafe)]
-#![feature(allow_internal_unstable)]
-#![feature(asm_experimental_arch)]
-#![feature(autodiff)]
-#![feature(cfg_sanitizer_cfi)]
-#![feature(cfg_target_thread_local)]
-#![feature(cfi_encoding)]
-#![feature(const_default)]
-#![feature(const_trait_impl)]
-#![feature(core_float_math)]
-#![feature(decl_macro)]
-#![feature(deprecated_suggestion)]
-#![feature(doc_cfg)]
-#![feature(doc_masked)]
-#![feature(doc_notable_trait)]
-#![feature(dropck_eyepatch)]
-#![feature(f16)]
-#![feature(f128)]
-#![feature(ffi_const)]
-#![feature(formatting_options)]
-#![feature(funnel_shifts)]
-#![feature(if_let_guard)]
-#![feature(intra_doc_pointers)]
-#![feature(iter_advance_by)]
-#![feature(iter_next_chunk)]
-#![feature(lang_items)]
-#![feature(link_cfg)]
-#![feature(linkage)]
-#![feature(macro_metavar_expr_concat)]
-#![feature(maybe_uninit_fill)]
-#![feature(min_specialization)]
-#![feature(must_not_suspend)]
-#![feature(needs_panic_runtime)]
-#![feature(negative_impls)]
-#![feature(never_type)]
-#![feature(optimize_attribute)]
-#![feature(prelude_import)]
-#![feature(rustc_attrs)]
-#![feature(rustdoc_internals)]
-#![feature(staged_api)]
-#![feature(stmt_expr_attributes)]
-#![feature(strict_provenance_lints)]
-#![feature(thread_local)]
-#![feature(try_blocks)]
-#![feature(try_trait_v2)]
-#![feature(type_alias_impl_trait)]
-// tidy-alphabetical-end
-//
-// Library features (core):
-// tidy-alphabetical-start
-#![feature(bstr)]
-#![feature(bstr_internals)]
-#![feature(cast_maybe_uninit)]
-#![feature(cfg_select)]
-#![feature(char_internals)]
-#![feature(clone_to_uninit)]
-#![feature(const_convert)]
-#![feature(core_intrinsics)]
-#![feature(core_io_borrowed_buf)]
-#![feature(drop_guard)]
-#![feature(duration_constants)]
-#![feature(error_generic_member_access)]
-#![feature(error_iter)]
-#![feature(exact_size_is_empty)]
-#![feature(exclusive_wrapper)]
-#![feature(extend_one)]
-#![feature(float_algebraic)]
-// #![feature(float_gamma)]
-#![feature(float_minimum_maximum)]
-#![feature(fmt_internals)]
-#![feature(fn_ptr_trait)]
-#![feature(generic_atomic)]
-#![feature(hasher_prefixfree_extras)]
-#![feature(hashmap_internals)]
-#![feature(hint_must_use)]
-#![feature(int_from_ascii)]
-#![feature(ip)]
-#![feature(maybe_uninit_array_assume_init)]
-#![feature(panic_can_unwind)]
-#![feature(panic_internals)]
-#![feature(pin_coerce_unsized_trait)]
-#![feature(pointer_is_aligned_to)]
-#![feature(portable_simd)]
-#![feature(ptr_as_uninit)]
-#![feature(ptr_mask)]
-#![feature(random)]
-#![feature(slice_internals)]
-#![feature(slice_ptr_get)]
-#![feature(slice_range)]
-#![feature(slice_split_once)]
-#![feature(std_internals)]
-#![feature(str_internals)]
-#![feature(sync_unsafe_cell)]
-#![feature(temporary_niche_types)]
-#![feature(ub_checks)]
-#![feature(used_with_arg)]
-// tidy-alphabetical-end
-//
-// Library features (alloc):
-// tidy-alphabetical-start
-#![feature(alloc_layout_extra)]
-#![feature(allocator_api)]
-#![feature(clone_from_ref)]
-#![feature(get_mut_unchecked)]
-#![feature(map_try_insert)]
-#![feature(slice_concat_trait)]
-#![feature(thin_box)]
-#![feature(try_reserve_kind)]
-#![feature(try_with_capacity)]
-#![feature(unique_rc_arc)]
-#![feature(wtf8_internals)]
-// tidy-alphabetical-end
-//
-// Library features (unwind):
-// tidy-alphabetical-start
-// #![feature(panic_unwind)]
-// tidy-alphabetical-end
-//
-// Library features (std_detect):
-// tidy-alphabetical-start
-// #![feature(stdarch_internal)]
-// tidy-alphabetical-end
-//
-// Only for re-exporting:
-// tidy-alphabetical-start
-#![feature(assert_matches)]
-#![feature(async_iterator)]
-#![feature(c_variadic)]
-#![feature(cfg_accessible)]
-#![feature(cfg_eval)]
-#![feature(concat_bytes)]
-#![feature(const_format_args)]
-#![feature(custom_test_frameworks)]
-#![feature(edition_panic)]
-#![feature(format_args_nl)]
-#![feature(log_syntax)]
-#![feature(test)]
-#![feature(trace_macros)]
-// tidy-alphabetical-end
-//
-// Only used in tests/benchmarks:
-//
-// Only for const-ness:
-// tidy-alphabetical-start
-#![feature(io_const_error)]
-// tidy-alphabetical-end
-//
-#![feature(c_size_t, unsafe_binders)]
-#![allow(clippy::doc_lazy_continuation, clippy::all)]
-#![allow(stable_features, incomplete_features, unexpected_cfgs)]
-#![allow(unused)]
-
-#[macro_use]
-extern crate alloc as alloc_crate;
-
-pub use core::any;
-pub use core::array;
-pub use core::async_iter;
-pub use core::cell;
-pub use core::char;
-pub use core::clone;
-pub use core::cmp;
-pub use core::convert;
-pub use core::default;
-pub use core::future;
-pub use core::hint;
-#[allow(deprecated, deprecated_in_future)]
-pub use core::i8;
-#[allow(deprecated, deprecated_in_future)]
-pub use core::i16;
-#[allow(deprecated, deprecated_in_future)]
-pub use core::i32;
-#[allow(deprecated, deprecated_in_future)]
-pub use core::i64;
-#[allow(deprecated, deprecated_in_future)]
-pub use core::i128;
-pub use core::intrinsics;
-#[allow(deprecated, deprecated_in_future)]
-pub use core::isize;
-pub use core::iter;
-pub use core::marker;
-pub use core::mem;
-pub use core::ops;
-pub use core::option;
-pub use core::pin;
-pub use core::ptr;
-pub use core::range;
-pub use core::result;
-#[allow(deprecated, deprecated_in_future)]
-pub use core::u8;
-#[allow(deprecated, deprecated_in_future)]
-pub use core::u16;
-#[allow(deprecated, deprecated_in_future)]
-pub use core::u32;
-#[allow(deprecated, deprecated_in_future)]
-pub use core::u64;
-#[allow(deprecated, deprecated_in_future)]
-pub use core::u128;
-pub use core::unsafe_binder;
-#[allow(deprecated, deprecated_in_future)]
-pub use core::usize;
-
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use alloc_crate::borrow;
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use alloc_crate::boxed;
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use alloc_crate::fmt;
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use alloc_crate::format;
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use alloc_crate::rc;
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use alloc_crate::slice;
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use alloc_crate::str;
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use alloc_crate::string;
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use alloc_crate::vec;
-
-#[stable(feature = "builtin_macro_prelude", since = "1.38.0")]
-pub use core::{
-    assert, cfg, column, compile_error, concat, const_format_args, env, file, format_args,
-    format_args_nl, include, include_bytes, include_str, line, log_syntax, module_path, option_env,
-    stringify, trace_macros,
-};
-
-pub mod ffi;
-pub mod hash;
-pub mod io;
-// pub mod fs;
-pub mod error;
-pub mod num;
-pub mod path;
-pub mod prelude;
-pub mod process;
-#[macro_use]
-pub mod rt;
-pub mod alloc;
-pub mod sync;
-pub mod sys;
-pub mod thread;
-pub mod time;
-
-#[prelude_import]
-#[allow(unused_imports)]
-pub use prelude::rust_2024::*;
-
-#[allow(unused)]
-mod sealed {
-    /// This trait being unreachable from outside the crate
-    /// prevents outside implementations of our extension traits.
-    /// This allows adding more trait methods in the future.
-    #[unstable(feature = "sealed", issue = "none")]
-    pub trait Sealed {}
-}
-
-pub use shared::fs;
-pub use shared::syscall;
-
-#[macro_export]
-macro_rules! print {
-    ($($args:expr),*) => {
-        $crate::syscall::write_string_temp(&format!($($args),*))
-    };
-}
-#[macro_export]
-macro_rules! println {
-    () => {
-        $crate::print!("");
-        // $crate::print!("\n\r");
-    };
-    ($($args:expr),*) => {
-        $crate::print!($($args),*);
-        // $crate::println!();
-    };
-}

crates/std/src/num/mod.rs

@@ -1,28 +0,0 @@
-//! Additional functionality for numerics.
-//!
-//! This module provides some extra types that are useful when doing numerical
-//! work. See the individual documentation for each piece for more information.
-
-#![stable(feature = "rust1", since = "1.0.0")]
-#![allow(missing_docs)]
-
-#[stable(feature = "int_error_matching", since = "1.55.0")]
-pub use core::num::IntErrorKind;
-#[stable(feature = "generic_nonzero", since = "1.79.0")]
-pub use core::num::NonZero;
-#[stable(feature = "saturating_int_impl", since = "1.74.0")]
-pub use core::num::Saturating;
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use core::num::Wrapping;
-#[unstable(
-    feature = "nonzero_internals",
-    reason = "implementation detail which may disappear or be replaced at any time",
-    issue = "none"
-)]
-pub use core::num::ZeroablePrimitive;
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use core::num::{FpCategory, ParseFloatError, ParseIntError, TryFromIntError};
-#[stable(feature = "signed_nonzero", since = "1.34.0")]
-pub use core::num::{NonZeroI8, NonZeroI16, NonZeroI32, NonZeroI64, NonZeroI128, NonZeroIsize};
-#[stable(feature = "nonzero", since = "1.28.0")]
-pub use core::num::{NonZeroU8, NonZeroU16, NonZeroU32, NonZeroU64, NonZeroU128, NonZeroUsize};

crates/std/src/prelude.rs

@@ -1,181 +0,0 @@
-pub mod rust_2024 {
-    pub use crate::print;
-    pub use crate::println;
-    pub use alloc::format;
-    pub use alloc::vec;
-
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[doc(no_inline)]
-    pub use crate::borrow::ToOwned;
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[doc(no_inline)]
-    pub use crate::boxed::Box;
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[doc(no_inline)]
-    pub use crate::string::{String, ToString};
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[doc(no_inline)]
-    pub use crate::vec::Vec;
-
-    // Re-exported built-in macros and traits
-    #[stable(feature = "builtin_macro_prelude", since = "1.38.0")]
-    #[doc(no_inline)]
-    #[expect(deprecated)]
-    pub use core::prelude::v1::{
-        Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd, assert, assert_eq,
-        assert_ne, cfg, column, compile_error, concat, debug_assert, debug_assert_eq,
-        debug_assert_ne, env, file, format_args, include, include_bytes, include_str, line,
-        matches, module_path, option_env, stringify, todo, r#try, unimplemented, unreachable,
-        write, writeln,
-    };
-
-    #[stable(feature = "builtin_macro_prelude", since = "1.38.0")]
-    #[doc(no_inline)]
-    pub use crate::thread_local;
-
-    #[stable(feature = "cfg_select", since = "1.95.0")]
-    #[doc(no_inline)]
-    pub use core::prelude::v1::cfg_select;
-
-    #[unstable(
-        feature = "concat_bytes",
-        issue = "87555",
-        reason = "`concat_bytes` is not stable enough for use and is subject to change"
-    )]
-    #[doc(no_inline)]
-    pub use core::prelude::v1::concat_bytes;
-
-    #[unstable(feature = "const_format_args", issue = "none")]
-    #[doc(no_inline)]
-    pub use core::prelude::v1::const_format_args;
-
-    #[unstable(
-        feature = "log_syntax",
-        issue = "29598",
-        reason = "`log_syntax!` is not stable enough for use and is subject to change"
-    )]
-    #[doc(no_inline)]
-    pub use core::prelude::v1::log_syntax;
-
-    #[unstable(
-        feature = "trace_macros",
-        issue = "29598",
-        reason = "`trace_macros` is not stable enough for use and is subject to change"
-    )]
-    #[doc(no_inline)]
-    pub use core::prelude::v1::trace_macros;
-
-    // Do not `doc(no_inline)` so that they become doc items on their own
-    // (no public module for them to be re-exported from).
-    #[stable(feature = "builtin_macro_prelude", since = "1.38.0")]
-    pub use core::prelude::v1::{
-        alloc_error_handler, bench, derive, global_allocator, test, test_case,
-    };
-
-    #[unstable(feature = "derive_const", issue = "118304")]
-    pub use core::prelude::v1::derive_const;
-
-    // Do not `doc(no_inline)` either.
-    #[unstable(
-        feature = "cfg_accessible",
-        issue = "64797",
-        reason = "`cfg_accessible` is not fully implemented"
-    )]
-    pub use core::prelude::v1::cfg_accessible;
-
-    // Do not `doc(no_inline)` either.
-    #[unstable(
-        feature = "cfg_eval",
-        issue = "82679",
-        reason = "`cfg_eval` is a recently implemented feature"
-    )]
-    pub use core::prelude::v1::cfg_eval;
-
-    // Do not `doc(no_inline)` either.
-    #[unstable(
-        feature = "type_ascription",
-        issue = "23416",
-        reason = "placeholder syntax for type ascription"
-    )]
-    pub use core::prelude::v1::type_ascribe;
-
-    // Do not `doc(no_inline)` either.
-    #[unstable(
-        feature = "deref_patterns",
-        issue = "87121",
-        reason = "placeholder syntax for deref patterns"
-    )]
-    pub use core::prelude::v1::deref;
-
-    // Do not `doc(no_inline)` either.
-    #[unstable(
-        feature = "type_alias_impl_trait",
-        issue = "63063",
-        reason = "`type_alias_impl_trait` has open design concerns"
-    )]
-    pub use core::prelude::v1::define_opaque;
-
-    #[unstable(feature = "extern_item_impls", issue = "125418")]
-    pub use core::prelude::v1::{eii, unsafe_eii};
-
-    #[unstable(feature = "eii_internals", issue = "none")]
-    pub use core::prelude::v1::eii_declaration;
-
-    #[stable(feature = "prelude_2021", since = "1.55.0")]
-    #[doc(no_inline)]
-    pub use core::prelude::rust_2021::*;
-
-    #[stable(feature = "prelude_2024", since = "1.85.0")]
-    #[doc(no_inline)]
-    pub use core::prelude::rust_2024::*;
-
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[doc(no_inline)]
-    pub use crate::convert::{AsMut, AsRef, From, Into};
-
-    extern crate alloc;
-
-    struct GlobalAllocator;
-
-    #[core::prelude::v1::global_allocator]
-    static GLOBAL_ALLOCATOR: GlobalAllocator = GlobalAllocator;
-
-    unsafe impl core::alloc::GlobalAlloc for GlobalAllocator {
-        unsafe fn alloc(&self, layout: core::alloc::Layout) -> *mut u8 {
-            crate::syscall::alloc(layout)
-        }
-
-        unsafe fn dealloc(&self, ptr: *mut u8, layout: core::alloc::Layout) {
-            crate::syscall::dealloc(ptr, layout)
-        }
-    }
-
-    #[panic_handler]
-    fn panic(_panic_info: &core::panic::PanicInfo) -> ! {
-        // TODO print
-        loop {}
-    }
-
-    /// # Safety
-    /// `argc` and `argv` are passed by the kernel
-    #[unsafe(no_mangle)]
-    pub unsafe extern "C" fn _start(argc: isize, argv: *const *const u8) -> isize {
-        unsafe extern "Rust" {
-            fn main(argc: isize, argv: *const *const u8) -> isize;
-        }
-
-        unsafe { main(argc, argv) }
-    }
-
-    #[lang = "start"]
-    pub fn lang_start<T: crate::process::Termination + 'static>(
-        main: fn() -> T,
-        argc: isize,
-        argv: *const *const u8,
-        _sigpipe: u8,
-    ) -> isize {
-        println!("{}", argc);
-        println!("{:?}", argv);
-        main().report().to_isize()
-    }
-}

crates/std/src/process.rs

@@ -1,29 +0,0 @@
-pub struct ExitCode(isize);
-
-impl ExitCode {
-    pub const SUCCESS: ExitCode = ExitCode(0);
-
-    pub fn to_isize(self) -> isize {
-        self.0
-    }
-}
-
-#[lang = "termination"]
-pub trait Termination {
-    /// Is called to get the representation of the value as status code.
-    /// This status code is returned to the operating system.
-    fn report(self) -> ExitCode;
-}
-
-impl Termination for () {
-    #[inline]
-    fn report(self) -> ExitCode {
-        ExitCode::SUCCESS
-    }
-}
-impl Termination for isize {
-    #[inline]
-    fn report(self) -> ExitCode {
-        ExitCode(self)
-    }
-}

crates/std/src/rt.rs

@@ -1,6 +0,0 @@
-macro_rules! rtabort {
-    ($($t:tt)*) => {{}};
-}
-macro_rules! rtprintpanic {
-    ($($t:tt)*) => {{}};
-}

crates/std/src/sync.rs

@@ -1,14 +0,0 @@
-pub mod once {
-    use crate::sys::sync as sys;
-    pub struct OnceState {
-        pub(crate) inner: sys::OnceState,
-    }
-    /// Used for the internal implementation of `sys::sync::once` on different platforms and the
-    /// [`LazyLock`](crate::sync::LazyLock) implementation.
-    pub(crate) enum OnceExclusiveState {
-        Incomplete,
-        Poisoned,
-        Complete,
-    }
-}
-pub use once::OnceState;

crates/std/src/sys/alloc/mod.rs

@@ -1,113 +0,0 @@
-#![forbid(unsafe_op_in_unsafe_fn)]
-
-use crate::alloc::{GlobalAlloc, Layout, System};
-use crate::ptr;
-
-// The minimum alignment guaranteed by the architecture. This value is used to
-// add fast paths for low alignment values.
-#[allow(dead_code)]
-const MIN_ALIGN: usize = if cfg!(any(
-    all(target_arch = "riscv32", any(target_os = "espidf", target_os = "zkvm")),
-    all(target_arch = "xtensa", target_os = "espidf"),
-)) {
-    // The allocator on the esp-idf and zkvm platforms guarantees 4 byte alignment.
-    4
-} else if cfg!(any(
-    target_arch = "x86",
-    target_arch = "arm",
-    target_arch = "m68k",
-    target_arch = "csky",
-    target_arch = "loongarch32",
-    target_arch = "mips",
-    target_arch = "mips32r6",
-    target_arch = "powerpc",
-    target_arch = "powerpc64",
-    target_arch = "sparc",
-    target_arch = "wasm32",
-    target_arch = "hexagon",
-    target_arch = "riscv32",
-    target_arch = "xtensa",
-)) {
-    8
-} else if cfg!(any(
-    target_arch = "x86_64",
-    target_arch = "aarch64",
-    target_arch = "arm64ec",
-    target_arch = "loongarch64",
-    target_arch = "mips64",
-    target_arch = "mips64r6",
-    target_arch = "s390x",
-    target_arch = "sparc64",
-    target_arch = "riscv64",
-    target_arch = "wasm64",
-)) {
-    16
-} else {
-    panic!("add a value for MIN_ALIGN")
-};
-
-#[allow(dead_code)]
-unsafe fn realloc_fallback(
-    alloc: &System,
-    ptr: *mut u8,
-    old_layout: Layout,
-    new_size: usize,
-) -> *mut u8 {
-    // SAFETY: Docs for GlobalAlloc::realloc require this to be valid
-    unsafe {
-        let new_layout = Layout::from_size_align_unchecked(new_size, old_layout.align());
-
-        let new_ptr = GlobalAlloc::alloc(alloc, new_layout);
-        if !new_ptr.is_null() {
-            let size = usize::min(old_layout.size(), new_size);
-            ptr::copy_nonoverlapping(ptr, new_ptr, size);
-            GlobalAlloc::dealloc(alloc, ptr, old_layout);
-        }
-
-        new_ptr
-    }
-}
-
-cfg_select! {
-    any(
-        target_family = "unix",
-        target_os = "wasi",
-        target_os = "teeos",
-        target_os = "trusty",
-    ) => {
-        mod unix;
-    }
-    target_os = "windows" => {
-        mod windows;
-    }
-    target_os = "hermit" => {
-        mod hermit;
-    }
-    target_os = "motor" => {
-        mod motor;
-    }
-    all(target_vendor = "fortanix", target_env = "sgx") => {
-        mod sgx;
-    }
-    target_os = "solid_asp3" => {
-        mod solid;
-    }
-    target_os = "uefi" => {
-        mod uefi;
-    }
-    target_os = "vexos" => {
-        mod vexos;
-    }
-    target_family = "wasm" => {
-        mod wasm;
-    }
-    target_os = "xous" => {
-        mod xous;
-    }
-    target_os = "zkvm" => {
-        mod zkvm;
-    }
-    target_os = "survos" => {
-        mod survos;
-    }
-}

crates/std/src/sys/alloc/survos.rs

@@ -1,14 +0,0 @@
-use crate::alloc::{GlobalAlloc, Layout, System};
-
-#[stable(feature = "alloc_system_type", since = "1.28.0")]
-unsafe impl GlobalAlloc for System {
-    #[inline]
-    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
-        unsafe { crate::syscall::alloc(layout) }
-    }
-
-    #[inline]
-    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
-        unsafe { crate::syscall::dealloc(ptr, layout) }
-    }
-}

crates/std/src/sys/cmath.rs

@@ -1,114 +0,0 @@
-#![cfg(not(test))]
-
-// These symbols are all defined by `libm`,
-// or by `compiler-builtins` on unsupported platforms.
-unsafe extern "C" {
-    pub safe fn acos(n: f64) -> f64;
-    pub safe fn asin(n: f64) -> f64;
-    pub safe fn atan(n: f64) -> f64;
-    pub safe fn atan2(a: f64, b: f64) -> f64;
-    pub safe fn cosh(n: f64) -> f64;
-    pub safe fn expm1(n: f64) -> f64;
-    pub safe fn expm1f(n: f32) -> f32;
-    #[cfg_attr(target_env = "msvc", link_name = "_hypot")]
-    pub safe fn hypot(x: f64, y: f64) -> f64;
-    #[cfg_attr(target_env = "msvc", link_name = "_hypotf")]
-    pub safe fn hypotf(x: f32, y: f32) -> f32;
-    pub safe fn log1p(n: f64) -> f64;
-    pub safe fn log1pf(n: f32) -> f32;
-    pub safe fn sinh(n: f64) -> f64;
-    pub safe fn tan(n: f64) -> f64;
-    pub safe fn tanh(n: f64) -> f64;
-    pub safe fn tgamma(n: f64) -> f64;
-    pub safe fn tgammaf(n: f32) -> f32;
-    pub safe fn lgamma_r(n: f64, s: &mut i32) -> f64;
-    #[cfg(not(target_os = "aix"))]
-    pub safe fn lgammaf_r(n: f32, s: &mut i32) -> f32;
-    pub safe fn erf(n: f64) -> f64;
-    pub safe fn erff(n: f32) -> f32;
-    pub safe fn erfc(n: f64) -> f64;
-    pub safe fn erfcf(n: f32) -> f32;
-
-    pub safe fn acosf128(n: f128) -> f128;
-    pub safe fn asinf128(n: f128) -> f128;
-    pub safe fn atanf128(n: f128) -> f128;
-    pub safe fn atan2f128(a: f128, b: f128) -> f128;
-    pub safe fn cbrtf128(n: f128) -> f128;
-    pub safe fn coshf128(n: f128) -> f128;
-    pub safe fn expm1f128(n: f128) -> f128;
-    pub safe fn hypotf128(x: f128, y: f128) -> f128;
-    pub safe fn log1pf128(n: f128) -> f128;
-    pub safe fn sinhf128(n: f128) -> f128;
-    pub safe fn tanf128(n: f128) -> f128;
-    pub safe fn tanhf128(n: f128) -> f128;
-    pub safe fn tgammaf128(n: f128) -> f128;
-    pub safe fn lgammaf128_r(n: f128, s: &mut i32) -> f128;
-    pub safe fn erff128(n: f128) -> f128;
-    pub safe fn erfcf128(n: f128) -> f128;
-}
-
-cfg_select! {
-    all(target_os = "windows", target_env = "msvc", target_arch = "x86") => {
-        // On 32-bit x86 MSVC these functions aren't defined, so we just define shims
-        // which promote everything to f64, perform the calculation, and then demote
-        // back to f32. While not precisely correct should be "correct enough" for now.
-        #[inline]
-        pub fn acosf(n: f32) -> f32 {
-            f64::acos(n as f64) as f32
-        }
-
-        #[inline]
-        pub fn asinf(n: f32) -> f32 {
-            f64::asin(n as f64) as f32
-        }
-
-        #[inline]
-        pub fn atan2f(n: f32, b: f32) -> f32 {
-            f64::atan2(n as f64, b as f64) as f32
-        }
-
-        #[inline]
-        pub fn atanf(n: f32) -> f32 {
-            f64::atan(n as f64) as f32
-        }
-
-        #[inline]
-        pub fn coshf(n: f32) -> f32 {
-            f64::cosh(n as f64) as f32
-        }
-
-        #[inline]
-        pub fn sinhf(n: f32) -> f32 {
-            f64::sinh(n as f64) as f32
-        }
-
-        #[inline]
-        pub fn tanf(n: f32) -> f32 {
-            f64::tan(n as f64) as f32
-        }
-
-        #[inline]
-        pub fn tanhf(n: f32) -> f32 {
-            f64::tanh(n as f64) as f32
-        }
-    }
-    _ => {
-        unsafe extern "C" {
-            pub safe fn acosf(n: f32) -> f32;
-            pub safe fn asinf(n: f32) -> f32;
-            pub safe fn atan2f(a: f32, b: f32) -> f32;
-            pub safe fn atanf(n: f32) -> f32;
-            pub safe fn coshf(n: f32) -> f32;
-            pub safe fn sinhf(n: f32) -> f32;
-            pub safe fn tanf(n: f32) -> f32;
-            pub safe fn tanhf(n: f32) -> f32;
-        }
-    }
-}
-
-// On AIX, we don't have lgammaf_r only the f64 version, so we can
-// use the f64 version lgamma_r
-#[cfg(target_os = "aix")]
-pub fn lgammaf_r(n: f32, s: &mut i32) -> f32 {
-    lgamma_r(n.into(), s) as f32
-}

crates/std/src/sys/configure_builtins.rs

@@ -1,62 +0,0 @@
-//! The configure builtins provides runtime support compiler-builtin features
-//! which require dynamic initialization to work as expected, e.g. aarch64
-//! outline-atomics.
-
-/// Enable LSE atomic operations at startup, if supported.
-///
-/// Linker sections are based on what [`ctor`] does, with priorities to run slightly before user
-/// code:
-///
-/// - Apple uses the section `__mod_init_func`, `mod_init_funcs` is needed to set
-///   `S_MOD_INIT_FUNC_POINTERS`. There doesn't seem to be a way to indicate priorities.
-/// - Windows uses `.CRT$XCT`, which is run before user constructors (these should use `.CRT$XCU`).
-/// - ELF uses `.init_array` with a priority of 90, which runs before our `ARGV_INIT_ARRAY`
-///   initializer (priority 99). Both are within the 0-100 implementation-reserved range, per docs
-///   for the [`prio-ctor-dtor`] warning, and this matches compiler-rt's `CONSTRUCTOR_PRIORITY`.
-///
-/// To save startup time, the initializer is only run if outline atomic routines from
-/// compiler-builtins may be used. If LSE is known to be available then the calls are never
-/// emitted, and if we build the C intrinsics then it has its own initializer using the symbol
-/// `__aarch64_have_lse_atomics`.
-///
-/// Initialization is done in a global constructor to so we get the same behavior regardless of
-/// whether Rust's `init` is used, or if we are in a `dylib` or `no_main` situation (as opposed
-/// to doing it as part of pre-main startup). This also matches C implementations.
-///
-/// Ideally `core` would have something similar, but detecting the CPU features requires the
-/// auxiliary vector from the OS. We do the initialization in `std` rather than as part of
-/// `compiler-builtins` because a builtins->std dependency isn't possible, and inlining parts of
-/// `std-detect` would be much messier.
-///
-/// [`ctor`]: https://github.com/mmastrac/rust-ctor/blob/63382b833ddcbfb8b064f4e86bfa1ed4026ff356/shared/src/macros/mod.rs#L522-L534
-/// [`prio-ctor-dtor`]: https://gcc.gnu.org/onlinedocs/gcc/Warning-Options.html
-#[cfg(all(
-    target_arch = "aarch64",
-    target_feature = "outline-atomics",
-    not(target_feature = "lse"),
-    not(feature = "compiler-builtins-c"),
-))]
-#[used]
-#[cfg_attr(target_vendor = "apple", unsafe(link_section = "__DATA,__mod_init_func,mod_init_funcs"))]
-#[cfg_attr(target_os = "windows", unsafe(link_section = ".CRT$XCT"))]
-#[cfg_attr(
-    not(any(target_vendor = "apple", target_os = "windows")),
-    unsafe(link_section = ".init_array.90")
-)]
-static RUST_LSE_INIT: extern "C" fn() = {
-    extern "C" fn init_lse() {
-        use crate::arch;
-
-        // This is provided by compiler-builtins::aarch64_outline_atomics.
-        unsafe extern "C" {
-            fn __rust_enable_lse();
-        }
-
-        if arch::is_aarch64_feature_detected!("lse") {
-            unsafe {
-                __rust_enable_lse();
-            }
-        }
-    }
-    init_lse
-};

crates/std/src/sys/env/common.rs

@@ -1,31 +0,0 @@
-use crate::ffi::OsString;
-use crate::{fmt, vec};
-
-pub struct Env {
-    iter: vec::IntoIter<(OsString, OsString)>,
-}
-
-impl Env {
-    pub(super) fn new(env: Vec<(OsString, OsString)>) -> Self {
-        Env { iter: env.into_iter() }
-    }
-}
-
-impl fmt::Debug for Env {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_list().entries(self.iter.as_slice()).finish()
-    }
-}
-
-impl !Send for Env {}
-impl !Sync for Env {}
-
-impl Iterator for Env {
-    type Item = (OsString, OsString);
-    fn next(&mut self) -> Option<(OsString, OsString)> {
-        self.iter.next()
-    }
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.iter.size_hint()
-    }
-}

crates/std/src/sys/env/mod.rs

@@ -1,62 +0,0 @@
-//! Platform-dependent environment variables abstraction.
-
-#![forbid(unsafe_op_in_unsafe_fn)]
-
-#[cfg(any(
-    target_family = "unix",
-    target_os = "hermit",
-    target_os = "motor",
-    all(target_vendor = "fortanix", target_env = "sgx"),
-    target_os = "solid_asp3",
-    target_os = "uefi",
-    target_os = "wasi",
-    target_os = "xous",
-))]
-mod common;
-
-cfg_select! {
-    target_family = "unix" => {
-        mod unix;
-        pub use unix::*;
-    }
-    target_family = "windows" => {
-        mod windows;
-        pub use windows::*;
-    }
-    target_os = "hermit" => {
-        mod hermit;
-        pub use hermit::*;
-    }
-    target_os = "motor" => {
-        mod motor;
-        pub use motor::*;
-    }
-    all(target_vendor = "fortanix", target_env = "sgx") => {
-        mod sgx;
-        pub use sgx::*;
-    }
-    target_os = "solid_asp3" => {
-        mod solid;
-        pub use solid::*;
-    }
-    target_os = "uefi" => {
-        mod uefi;
-        pub use uefi::*;
-    }
-    target_os = "wasi" => {
-        mod wasi;
-        pub use wasi::*;
-    }
-    target_os = "xous" => {
-        mod xous;
-        pub use xous::*;
-    }
-    target_os = "zkvm" => {
-        mod zkvm;
-        pub use zkvm::*;
-    }
-    _ => {
-        mod unsupported;
-        pub use unsupported::*;
-    }
-}

crates/std/src/sys/env/unsupported.rs

@@ -1,33 +0,0 @@
-use crate::ffi::{OsStr, OsString};
-use crate::{fmt, io};
-
-pub struct Env(!);
-
-impl fmt::Debug for Env {
-    fn fmt(&self, _: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.0
-    }
-}
-
-impl Iterator for Env {
-    type Item = (OsString, OsString);
-    fn next(&mut self) -> Option<(OsString, OsString)> {
-        self.0
-    }
-}
-
-pub fn env() -> Env {
-    panic!("not supported on this platform")
-}
-
-pub fn getenv(_: &OsStr) -> Option<OsString> {
-    None
-}
-
-pub unsafe fn setenv(_: &OsStr, _: &OsStr) -> io::Result<()> {
-    Err(io::const_error!(io::ErrorKind::Unsupported, "cannot set env vars on this platform"))
-}
-
-pub unsafe fn unsetenv(_: &OsStr) -> io::Result<()> {
-    Err(io::const_error!(io::ErrorKind::Unsupported, "cannot unset env vars on this platform"))
-}

crates/std/src/sys/env_consts.rs

@@ -1,426 +0,0 @@
-//! Constants associated with each target.
-
-// Replaces the #[else] gate with #[cfg(not(any(…)))] of all the other gates.
-// This ensures that they must be mutually exclusive and do not have precedence
-// like cfg_select!.
-macro cfg_unordered(
-    $(#[cfg($cfg:meta)] $os:item)*
-    #[else] $fallback:item
-) {
-    $(#[cfg($cfg)] $os)*
-    #[cfg(not(any($($cfg),*)))] $fallback
-}
-
-// Keep entries sorted alphabetically and mutually exclusive.
-
-cfg_unordered! {
-
-#[cfg(target_os = "aix")]
-pub mod os {
-    pub const FAMILY: &str = "unix";
-    pub const OS: &str = "aix";
-    pub const DLL_PREFIX: &str = "lib";
-    pub const DLL_SUFFIX: &str = ".a";
-    pub const DLL_EXTENSION: &str = "a";
-    pub const EXE_SUFFIX: &str = "";
-    pub const EXE_EXTENSION: &str = "";
-}
-
-#[cfg(target_os = "android")]
-pub mod os {
-    pub const FAMILY: &str = "unix";
-    pub const OS: &str = "android";
-    pub const DLL_PREFIX: &str = "lib";
-    pub const DLL_SUFFIX: &str = ".so";
-    pub const DLL_EXTENSION: &str = "so";
-    pub const EXE_SUFFIX: &str = "";
-    pub const EXE_EXTENSION: &str = "";
-}
-
-#[cfg(target_os = "cygwin")]
-pub mod os {
-    pub const FAMILY: &str = "unix";
-    pub const OS: &str = "cygwin";
-    pub const DLL_PREFIX: &str = "";
-    pub const DLL_SUFFIX: &str = ".dll";
-    pub const DLL_EXTENSION: &str = "dll";
-    pub const EXE_SUFFIX: &str = ".exe";
-    pub const EXE_EXTENSION: &str = "exe";
-}
-
-#[cfg(target_os = "dragonfly")]
-pub mod os {
-    pub const FAMILY: &str = "unix";
-    pub const OS: &str = "dragonfly";
-    pub const DLL_PREFIX: &str = "lib";
-    pub const DLL_SUFFIX: &str = ".so";
-    pub const DLL_EXTENSION: &str = "so";
-    pub const EXE_SUFFIX: &str = "";
-    pub const EXE_EXTENSION: &str = "";
-}
-
-#[cfg(target_os = "emscripten")]
-pub mod os {
-    pub const FAMILY: &str = "unix";
-    pub const OS: &str = "emscripten";
-    pub const DLL_PREFIX: &str = "lib";
-    pub const DLL_SUFFIX: &str = ".so";
-    pub const DLL_EXTENSION: &str = "so";
-    pub const EXE_SUFFIX: &str = ".js";
-    pub const EXE_EXTENSION: &str = "js";
-}
-
-#[cfg(target_os = "espidf")]
-pub mod os {
-    pub const FAMILY: &str = "unix";
-    pub const OS: &str = "espidf";
-    pub const DLL_PREFIX: &str = "lib";
-    pub const DLL_SUFFIX: &str = ".so";
-    pub const DLL_EXTENSION: &str = "so";
-    pub const EXE_SUFFIX: &str = "";
-    pub const EXE_EXTENSION: &str = "";
-}
-
-#[cfg(target_os = "freebsd")]
-pub mod os {
-    pub const FAMILY: &str = "unix";
-    pub const OS: &str = "freebsd";
-    pub const DLL_PREFIX: &str = "lib";
-    pub const DLL_SUFFIX: &str = ".so";
-    pub const DLL_EXTENSION: &str = "so";
-    pub const EXE_SUFFIX: &str = "";
-    pub const EXE_EXTENSION: &str = "";
-}
-
-#[cfg(target_os = "fuchsia")]
-pub mod os {
-    pub const FAMILY: &str = "unix";
-    pub const OS: &str = "fuchsia";
-    pub const DLL_PREFIX: &str = "lib";
-    pub const DLL_SUFFIX: &str = ".so";
-    pub const DLL_EXTENSION: &str = "so";
-    pub const EXE_SUFFIX: &str = "";
-    pub const EXE_EXTENSION: &str = "";
-}
-
-#[cfg(target_os = "haiku")]
-pub mod os {
-    pub const FAMILY: &str = "unix";
-    pub const OS: &str = "haiku";
-    pub const DLL_PREFIX: &str = "lib";
-    pub const DLL_SUFFIX: &str = ".so";
-    pub const DLL_EXTENSION: &str = "so";
-    pub const EXE_SUFFIX: &str = "";
-    pub const EXE_EXTENSION: &str = "";
-}
-
-#[cfg(target_os = "hermit")]
-pub mod os {
-    pub const FAMILY: &str = "";
-    pub const OS: &str = "hermit";
-    pub const DLL_PREFIX: &str = "";
-    pub const DLL_SUFFIX: &str = "";
-    pub const DLL_EXTENSION: &str = "";
-    pub const EXE_SUFFIX: &str = "";
-    pub const EXE_EXTENSION: &str = "";
-}
-
-#[cfg(target_os = "horizon")]
-pub mod os {
-    pub const FAMILY: &str = "unix";
-    pub const OS: &str = "horizon";
-    pub const DLL_PREFIX: &str = "lib";
-    pub const DLL_SUFFIX: &str = ".so";
-    pub const DLL_EXTENSION: &str = "so";
-    pub const EXE_SUFFIX: &str = ".elf";
-    pub const EXE_EXTENSION: &str = "elf";
-}
-
-#[cfg(target_os = "hurd")]
-pub mod os {
-    pub const FAMILY: &str = "unix";
-    pub const OS: &str = "hurd";
-    pub const DLL_PREFIX: &str = "lib";
-    pub const DLL_SUFFIX: &str = ".so";
-    pub const DLL_EXTENSION: &str = "so";
-    pub const EXE_SUFFIX: &str = "";
-    pub const EXE_EXTENSION: &str = "";
-}
-
-#[cfg(target_os = "illumos")]
-pub mod os {
-    pub const FAMILY: &str = "unix";
-    pub const OS: &str = "illumos";
-    pub const DLL_PREFIX: &str = "lib";
-    pub const DLL_SUFFIX: &str = ".so";
-    pub const DLL_EXTENSION: &str = "so";
-    pub const EXE_SUFFIX: &str = "";
-    pub const EXE_EXTENSION: &str = "";
-}
-
-#[cfg(target_os = "ios")]
-pub mod os {
-    pub const FAMILY: &str = "unix";
-    pub const OS: &str = "ios";
-    pub const DLL_PREFIX: &str = "lib";
-    pub const DLL_SUFFIX: &str = ".dylib";
-    pub const DLL_EXTENSION: &str = "dylib";
-    pub const EXE_SUFFIX: &str = "";
-    pub const EXE_EXTENSION: &str = "";
-}
-
-#[cfg(target_os = "l4re")]
-pub mod os {
-    pub const FAMILY: &str = "unix";
-    pub const OS: &str = "l4re";
-    pub const DLL_PREFIX: &str = "lib";
-    pub const DLL_SUFFIX: &str = ".so";
-    pub const DLL_EXTENSION: &str = "so";
-    pub const EXE_SUFFIX: &str = "";
-    pub const EXE_EXTENSION: &str = "";
-}
-
-#[cfg(target_os = "linux")]
-pub mod os {
-    pub const FAMILY: &str = "unix";
-    pub const OS: &str = "linux";
-    pub const DLL_PREFIX: &str = "lib";
-    pub const DLL_SUFFIX: &str = ".so";
-    pub const DLL_EXTENSION: &str = "so";
-    pub const EXE_SUFFIX: &str = "";
-    pub const EXE_EXTENSION: &str = "";
-}
-
-#[cfg(target_os = "macos")]
-pub mod os {
-    pub const FAMILY: &str = "unix";
-    pub const OS: &str = "macos";
-    pub const DLL_PREFIX: &str = "lib";
-    pub const DLL_SUFFIX: &str = ".dylib";
-    pub const DLL_EXTENSION: &str = "dylib";
-    pub const EXE_SUFFIX: &str = "";
-    pub const EXE_EXTENSION: &str = "";
-}
-
-#[cfg(target_os = "netbsd")]
-pub mod os {
-    pub const FAMILY: &str = "unix";
-    pub const OS: &str = "netbsd";
-    pub const DLL_PREFIX: &str = "lib";
-    pub const DLL_SUFFIX: &str = ".so";
-    pub const DLL_EXTENSION: &str = "so";
-    pub const EXE_SUFFIX: &str = "";
-    pub const EXE_EXTENSION: &str = "";
-}
-
-#[cfg(target_os = "nto")]
-pub mod os {
-    pub const FAMILY: &str = "unix";
-    pub const OS: &str = "nto";
-    pub const DLL_PREFIX: &str = "lib";
-    pub const DLL_SUFFIX: &str = ".so";
-    pub const DLL_EXTENSION: &str = "so";
-    pub const EXE_SUFFIX: &str = "";
-    pub const EXE_EXTENSION: &str = "";
-}
-
-#[cfg(target_os = "nuttx")]
-pub mod os {
-    pub const FAMILY: &str = "unix";
-    pub const OS: &str = "nuttx";
-    pub const DLL_PREFIX: &str = "lib";
-    pub const DLL_SUFFIX: &str = ".so";
-    pub const DLL_EXTENSION: &str = "so";
-    pub const EXE_SUFFIX: &str = "";
-    pub const EXE_EXTENSION: &str = "";
-}
-
-#[cfg(target_os = "openbsd")]
-pub mod os {
-    pub const FAMILY: &str = "unix";
-    pub const OS: &str = "openbsd";
-    pub const DLL_PREFIX: &str = "lib";
-    pub const DLL_SUFFIX: &str = ".so";
-    pub const DLL_EXTENSION: &str = "so";
-    pub const EXE_SUFFIX: &str = "";
-    pub const EXE_EXTENSION: &str = "";
-}
-
-#[cfg(target_os = "redox")]
-pub mod os {
-    pub const FAMILY: &str = "unix";
-    pub const OS: &str = "redox";
-    pub const DLL_PREFIX: &str = "lib";
-    pub const DLL_SUFFIX: &str = ".so";
-    pub const DLL_EXTENSION: &str = "so";
-    pub const EXE_SUFFIX: &str = "";
-    pub const EXE_EXTENSION: &str = "";
-}
-
-#[cfg(target_os = "rtems")]
-pub mod os {
-    pub const FAMILY: &str = "unix";
-    pub const OS: &str = "rtems";
-    pub const DLL_PREFIX: &str = "lib";
-    pub const DLL_SUFFIX: &str = ".so";
-    pub const DLL_EXTENSION: &str = "so";
-    pub const EXE_SUFFIX: &str = "";
-    pub const EXE_EXTENSION: &str = "";
-}
-
-#[cfg(all(target_vendor = "fortanix", target_env = "sgx"))]
-pub mod os {
-    pub const FAMILY: &str = "";
-    pub const OS: &str = "";
-    pub const DLL_PREFIX: &str = "";
-    pub const DLL_SUFFIX: &str = ".sgxs";
-    pub const DLL_EXTENSION: &str = "sgxs";
-    pub const EXE_SUFFIX: &str = ".sgxs";
-    pub const EXE_EXTENSION: &str = "sgxs";
-}
-
-#[cfg(target_os = "solaris")]
-pub mod os {
-    pub const FAMILY: &str = "unix";
-    pub const OS: &str = "solaris";
-    pub const DLL_PREFIX: &str = "lib";
-    pub const DLL_SUFFIX: &str = ".so";
-    pub const DLL_EXTENSION: &str = "so";
-    pub const EXE_SUFFIX: &str = "";
-    pub const EXE_EXTENSION: &str = "";
-}
-
-#[cfg(target_os = "solid_asp3")]
-pub mod os {
-    pub const FAMILY: &str = "itron";
-    pub const OS: &str = "solid";
-    pub const DLL_PREFIX: &str = "";
-    pub const DLL_SUFFIX: &str = ".so";
-    pub const DLL_EXTENSION: &str = "so";
-    pub const EXE_SUFFIX: &str = "";
-    pub const EXE_EXTENSION: &str = "";
-}
-
-#[cfg(target_os = "tvos")]
-pub mod os {
-    pub const FAMILY: &str = "unix";
-    pub const OS: &str = "tvos";
-    pub const DLL_PREFIX: &str = "lib";
-    pub const DLL_SUFFIX: &str = ".dylib";
-    pub const DLL_EXTENSION: &str = "dylib";
-    pub const EXE_SUFFIX: &str = "";
-    pub const EXE_EXTENSION: &str = "";
-}
-
-#[cfg(target_os = "uefi")]
-pub mod os {
-    pub const FAMILY: &str = "";
-    pub const OS: &str = "uefi";
-    pub const DLL_PREFIX: &str = "";
-    pub const DLL_SUFFIX: &str = "";
-    pub const DLL_EXTENSION: &str = "";
-    pub const EXE_SUFFIX: &str = ".efi";
-    pub const EXE_EXTENSION: &str = "efi";
-}
-
-#[cfg(target_os = "vexos")]
-pub mod os {
-    pub const FAMILY: &str = "";
-    pub const OS: &str = "vexos";
-    pub const DLL_PREFIX: &str = "";
-    pub const DLL_SUFFIX: &str = "";
-    pub const DLL_EXTENSION: &str = "";
-    pub const EXE_SUFFIX: &str = ".bin";
-    pub const EXE_EXTENSION: &str = "bin";
-}
-
-#[cfg(target_os = "visionos")]
-pub mod os {
-    pub const FAMILY: &str = "unix";
-    pub const OS: &str = "visionos";
-    pub const DLL_PREFIX: &str = "lib";
-    pub const DLL_SUFFIX: &str = ".dylib";
-    pub const DLL_EXTENSION: &str = "dylib";
-    pub const EXE_SUFFIX: &str = "";
-    pub const EXE_EXTENSION: &str = "";
-}
-
-#[cfg(target_os = "vita")]
-pub mod os {
-    pub const FAMILY: &str = "unix";
-    pub const OS: &str = "vita";
-    pub const DLL_PREFIX: &str = "lib";
-    pub const DLL_SUFFIX: &str = ".so";
-    pub const DLL_EXTENSION: &str = "so";
-    pub const EXE_SUFFIX: &str = ".elf";
-    pub const EXE_EXTENSION: &str = "elf";
-}
-
-#[cfg(target_os = "vxworks")]
-pub mod os {
-    pub const FAMILY: &str = "unix";
-    pub const OS: &str = "vxworks";
-    pub const DLL_PREFIX: &str = "lib";
-    pub const DLL_SUFFIX: &str = ".so";
-    pub const DLL_EXTENSION: &str = "so";
-    pub const EXE_SUFFIX: &str = "";
-    pub const EXE_EXTENSION: &str = "";
-}
-
-#[cfg(all(target_family = "wasm", not(any(target_os = "emscripten", target_os = "linux"))))]
-pub mod os {
-    pub const FAMILY: &str = "";
-    pub const OS: &str = "";
-    pub const DLL_PREFIX: &str = "";
-    pub const DLL_SUFFIX: &str = ".wasm";
-    pub const DLL_EXTENSION: &str = "wasm";
-    pub const EXE_SUFFIX: &str = ".wasm";
-    pub const EXE_EXTENSION: &str = "wasm";
-}
-
-#[cfg(target_os = "watchos")]
-pub mod os {
-    pub const FAMILY: &str = "unix";
-    pub const OS: &str = "watchos";
-    pub const DLL_PREFIX: &str = "lib";
-    pub const DLL_SUFFIX: &str = ".dylib";
-    pub const DLL_EXTENSION: &str = "dylib";
-    pub const EXE_SUFFIX: &str = "";
-    pub const EXE_EXTENSION: &str = "";
-}
-
-#[cfg(target_os = "windows")]
-pub mod os {
-    pub const FAMILY: &str = "windows";
-    pub const OS: &str = "windows";
-    pub const DLL_PREFIX: &str = "";
-    pub const DLL_SUFFIX: &str = ".dll";
-    pub const DLL_EXTENSION: &str = "dll";
-    pub const EXE_SUFFIX: &str = ".exe";
-    pub const EXE_EXTENSION: &str = "exe";
-}
-
-#[cfg(target_os = "zkvm")]
-pub mod os {
-    pub const FAMILY: &str = "";
-    pub const OS: &str = "";
-    pub const DLL_PREFIX: &str = "";
-    pub const DLL_SUFFIX: &str = ".elf";
-    pub const DLL_EXTENSION: &str = "elf";
-    pub const EXE_SUFFIX: &str = ".elf";
-    pub const EXE_EXTENSION: &str = "elf";
-}
-
-// The fallback when none of the other gates match.
-#[else]
-pub mod os {
-    pub const FAMILY: &str = "";
-    pub const OS: &str = "";
-    pub const DLL_PREFIX: &str = "";
-    pub const DLL_SUFFIX: &str = "";
-    pub const DLL_EXTENSION: &str = "";
-    pub const EXE_SUFFIX: &str = "";
-    pub const EXE_EXTENSION: &str = "";
-}
-
-}

crates/std/src/sys/exit.rs

@@ -1,143 +0,0 @@
-cfg_select! {
-    target_os = "linux" => {
-        /// Mitigation for <https://github.com/rust-lang/rust/issues/126600>
-        ///
-        /// On glibc, `libc::exit` has been observed to not always be thread-safe.
-        /// It is currently unclear whether that is a glibc bug or allowed by the standard.
-        /// To mitigate this problem, we ensure that only one
-        /// Rust thread calls `libc::exit` (or returns from `main`) by calling this function before
-        /// calling `libc::exit` (or returning from `main`).
-        ///
-        /// Technically, this is not enough to ensure soundness, since other code directly calling
-        /// `libc::exit` will still race with this.
-        ///
-        /// *This function does not itself call `libc::exit`.* This is so it can also be used
-        /// to guard returning from `main`.
-        ///
-        /// This function will return only the first time it is called in a process.
-        ///
-        /// * If it is called again on the same thread as the first call, it will abort.
-        /// * If it is called again on a different thread, it will wait in a loop
-        ///   (waiting for the process to exit).
-        pub fn unique_thread_exit() {
-            use crate::ffi::c_int;
-            use crate::ptr;
-            use crate::sync::atomic::AtomicPtr;
-            use crate::sync::atomic::Ordering::{Acquire, Relaxed};
-
-            static EXITING_THREAD_ID: AtomicPtr<c_int> = AtomicPtr::new(ptr::null_mut());
-
-            // We use the address of `errno` as a cheap and safe way to identify
-            // threads. As the C standard mandates that `errno` must have thread
-            // storage duration, we can rely on its address not changing over the
-            // lifetime of the thread. Additionally, accesses to `errno` are
-            // async-signal-safe, so this function is available in all imaginable
-            // circumstances.
-            let this_thread_id = crate::sys::io::errno_location();
-            match EXITING_THREAD_ID.compare_exchange(ptr::null_mut(), this_thread_id, Acquire, Relaxed) {
-                Ok(_) => {
-                    // This is the first thread to call `unique_thread_exit`,
-                    // and this is the first time it is called. Continue exiting.
-                }
-                Err(exiting_thread_id) if exiting_thread_id == this_thread_id => {
-                    // This is the first thread to call `unique_thread_exit`,
-                    // but this is the second time it is called.
-                    // Abort the process.
-                    core::panicking::panic_nounwind("std::process::exit called re-entrantly")
-                }
-                Err(_) => {
-                    // This is not the first thread to call `unique_thread_exit`.
-                    // Pause until the process exits.
-                    loop {
-                        // Safety: libc::pause is safe to call.
-                        unsafe { libc::pause(); }
-                    }
-                }
-            }
-        }
-    }
-    _ => {
-        /// Mitigation for <https://github.com/rust-lang/rust/issues/126600>
-        ///
-        /// Mitigation is ***NOT*** implemented on this platform, either because this platform
-        /// is not affected, or because mitigation is not yet implemented for this platform.
-        #[cfg_attr(any(test, doctest), expect(dead_code))]
-        pub fn unique_thread_exit() {
-            // Mitigation not required on platforms where `exit` is thread-safe.
-        }
-    }
-}
-
-pub fn exit(code: i32) -> ! {
-    cfg_select! {
-        target_os = "hermit" => {
-            unsafe { hermit_abi::exit(code) }
-        }
-        target_os = "linux" => {
-            unsafe {
-                unique_thread_exit();
-                libc::exit(code)
-            }
-        }
-        target_os = "motor" => {
-            moto_rt::process::exit(code)
-        }
-        all(target_vendor = "fortanix", target_env = "sgx") => {
-            crate::sys::pal::abi::exit_with_code(code as _)
-        }
-        target_os = "solid_asp3" => {
-            rtabort!("exit({}) called", code)
-        }
-        target_os = "teeos" => {
-            let _ = code;
-            panic!("TA should not call `exit`")
-        }
-        target_os = "uefi" => {
-            use r_efi::base::Status;
-
-            use crate::os::uefi::env;
-
-            if let (Some(boot_services), Some(handle)) =
-                (env::boot_services(), env::try_image_handle())
-            {
-                let boot_services = boot_services.cast::<r_efi::efi::BootServices>();
-                let _ = unsafe {
-                    ((*boot_services.as_ptr()).exit)(
-                        handle.as_ptr(),
-                        Status::from_usize(code as usize),
-                        0,
-                        crate::ptr::null_mut(),
-                    )
-                };
-            }
-            crate::intrinsics::abort()
-        }
-        any(
-            target_family = "unix",
-            target_os = "wasi",
-        ) => {
-            unsafe { libc::exit(code as crate::ffi::c_int) }
-        }
-        target_os = "vexos" => {
-            let _ = code;
-
-            unsafe {
-                vex_sdk::vexSystemExitRequest();
-
-                loop {
-                    vex_sdk::vexTasksRun();
-                }
-            }
-        }
-        target_os = "windows" => {
-            unsafe { crate::sys::pal::c::ExitProcess(code as u32) }
-        }
-        target_os = "xous" => {
-            crate::os::xous::ffi::exit(code as u32)
-        }
-        _ => {
-            let _ = code;
-            crate::intrinsics::abort()
-        }
-    }
-}

crates/std/src/sys/fs/common.rs

@@ -1,81 +0,0 @@
-#![allow(dead_code)] // not used on all platforms
-
-use crate::io::{self, Error, ErrorKind};
-use crate::path::{Path, PathBuf};
-use crate::sys::fs::{File, OpenOptions};
-use crate::sys::helpers::ignore_notfound;
-use crate::{fmt, fs};
-
-pub(crate) const NOT_FILE_ERROR: Error = io::const_error!(
-    ErrorKind::InvalidInput,
-    "the source path is neither a regular file nor a symlink to a regular file",
-);
-
-pub fn copy(from: &Path, to: &Path) -> io::Result<u64> {
-    let mut reader = fs::File::open(from)?;
-    let metadata = reader.metadata()?;
-
-    if !metadata.is_file() {
-        return Err(NOT_FILE_ERROR);
-    }
-
-    let mut writer = fs::File::create(to)?;
-    let perm = metadata.permissions();
-
-    let ret = io::copy(&mut reader, &mut writer)?;
-    writer.set_permissions(perm)?;
-    Ok(ret)
-}
-
-pub fn remove_dir_all(path: &Path) -> io::Result<()> {
-    let filetype = fs::symlink_metadata(path)?.file_type();
-    if filetype.is_symlink() { fs::remove_file(path) } else { remove_dir_all_recursive(path) }
-}
-
-fn remove_dir_all_recursive(path: &Path) -> io::Result<()> {
-    for child in fs::read_dir(path)? {
-        let result: io::Result<()> = try {
-            let child = child?;
-            if child.file_type()?.is_dir() {
-                remove_dir_all_recursive(&child.path())?;
-            } else {
-                fs::remove_file(&child.path())?;
-            }
-        };
-        // ignore internal NotFound errors to prevent race conditions
-        if let Err(err) = &result
-            && err.kind() != io::ErrorKind::NotFound
-        {
-            return result;
-        }
-    }
-    ignore_notfound(fs::remove_dir(path))
-}
-
-pub fn exists(path: &Path) -> io::Result<bool> {
-    match fs::metadata(path) {
-        Ok(_) => Ok(true),
-        Err(error) if error.kind() == io::ErrorKind::NotFound => Ok(false),
-        Err(error) => Err(error),
-    }
-}
-
-pub struct Dir {
-    path: PathBuf,
-}
-
-impl Dir {
-    pub fn open(path: &Path, _opts: &OpenOptions) -> io::Result<Self> {
-        path.canonicalize().map(|path| Self { path })
-    }
-
-    pub fn open_file(&self, path: &Path, opts: &OpenOptions) -> io::Result<File> {
-        File::open(&self.path.join(path), &opts)
-    }
-}
-
-impl fmt::Debug for Dir {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("Dir").field("path", &self.path).finish()
-    }
-}

crates/std/src/sys/fs/mod.rs

@@ -1,173 +0,0 @@
-#![deny(unsafe_op_in_unsafe_fn)]
-
-use crate::io;
-use crate::path::{Path, PathBuf};
-
-pub mod common;
-
-cfg_select! {
-    any(target_family = "unix", target_os = "wasi") => {
-        mod unix;
-        use unix as imp;
-        #[cfg(not(target_os = "wasi"))]
-        pub use unix::{chown, fchown, lchown, mkfifo};
-        #[cfg(not(any(target_os = "fuchsia", target_os = "wasi")))]
-        pub use unix::chroot;
-        #[cfg(not(target_os = "wasi"))]
-        pub(crate) use unix::debug_assert_fd_is_open;
-        #[cfg(any(target_os = "linux", target_os = "android"))]
-        pub(super) use unix::CachedFileMetadata;
-        use crate::sys::helpers::run_path_with_cstr as with_native_path;
-    }
-    target_os = "windows" => {
-        mod windows;
-        use windows as imp;
-        pub use windows::{symlink_inner, junction_point};
-        use crate::sys::path::with_native_path;
-    }
-    target_os = "hermit" => {
-        mod hermit;
-        use hermit as imp;
-    }
-    target_os = "motor" => {
-        mod motor;
-        use motor as imp;
-    }
-    target_os = "solid_asp3" => {
-        mod solid;
-        use solid as imp;
-    }
-    target_os = "uefi" => {
-        mod uefi;
-        use uefi as imp;
-    }
-    target_os = "vexos" => {
-        mod vexos;
-        use vexos as imp;
-    }
-    _ => {
-        mod unsupported;
-        use unsupported as imp;
-    }
-}
-
-// FIXME: Replace this with platform-specific path conversion functions.
-#[cfg(not(any(target_family = "unix", target_os = "windows", target_os = "wasi")))]
-#[inline]
-pub fn with_native_path<T>(path: &Path, f: &dyn Fn(&Path) -> io::Result<T>) -> io::Result<T> {
-    f(path)
-}
-
-pub use imp::{
-    Dir, DirBuilder, DirEntry, File, FileAttr, FilePermissions, FileTimes, FileType, OpenOptions,
-    ReadDir,
-};
-
-pub fn read_dir(path: &Path) -> io::Result<ReadDir> {
-    // FIXME: use with_native_path on all platforms
-    imp::readdir(path)
-}
-
-pub fn remove_file(path: &Path) -> io::Result<()> {
-    with_native_path(path, &imp::unlink)
-}
-
-pub fn rename(old: &Path, new: &Path) -> io::Result<()> {
-    with_native_path(old, &|old| with_native_path(new, &|new| imp::rename(old, new)))
-}
-
-pub fn remove_dir(path: &Path) -> io::Result<()> {
-    with_native_path(path, &imp::rmdir)
-}
-
-pub fn remove_dir_all(path: &Path) -> io::Result<()> {
-    // FIXME: use with_native_path on all platforms
-    #[cfg(not(windows))]
-    return imp::remove_dir_all(path);
-    #[cfg(windows)]
-    with_native_path(path, &imp::remove_dir_all)
-}
-
-pub fn read_link(path: &Path) -> io::Result<PathBuf> {
-    with_native_path(path, &imp::readlink)
-}
-
-pub fn symlink(original: &Path, link: &Path) -> io::Result<()> {
-    // FIXME: use with_native_path on all platforms
-    #[cfg(windows)]
-    return imp::symlink(original, link);
-    #[cfg(not(windows))]
-    with_native_path(original, &|original| {
-        with_native_path(link, &|link| imp::symlink(original, link))
-    })
-}
-
-pub fn hard_link(original: &Path, link: &Path) -> io::Result<()> {
-    with_native_path(original, &|original| {
-        with_native_path(link, &|link| imp::link(original, link))
-    })
-}
-
-pub fn metadata(path: &Path) -> io::Result<FileAttr> {
-    with_native_path(path, &imp::stat)
-}
-
-pub fn symlink_metadata(path: &Path) -> io::Result<FileAttr> {
-    with_native_path(path, &imp::lstat)
-}
-
-pub fn set_permissions(path: &Path, perm: FilePermissions) -> io::Result<()> {
-    with_native_path(path, &|path| imp::set_perm(path, perm.clone()))
-}
-
-#[cfg(all(unix, not(target_os = "vxworks")))]
-pub fn set_permissions_nofollow(path: &Path, perm: crate::fs::Permissions) -> io::Result<()> {
-    use crate::fs::OpenOptions;
-
-    let mut options = OpenOptions::new();
-
-    // ESP-IDF and Horizon do not support O_NOFOLLOW, so we skip setting it.
-    // Their filesystems do not have symbolic links, so no special handling is required.
-    #[cfg(not(any(target_os = "espidf", target_os = "horizon")))]
-    {
-        use crate::os::unix::fs::OpenOptionsExt;
-        options.custom_flags(libc::O_NOFOLLOW);
-    }
-
-    options.open(path)?.set_permissions(perm)
-}
-
-#[cfg(any(not(unix), target_os = "vxworks"))]
-pub fn set_permissions_nofollow(_path: &Path, _perm: crate::fs::Permissions) -> io::Result<()> {
-    crate::unimplemented!(
-        "`set_permissions_nofollow` is currently only implemented on Unix platforms"
-    )
-}
-
-pub fn canonicalize(path: &Path) -> io::Result<PathBuf> {
-    with_native_path(path, &imp::canonicalize)
-}
-
-pub fn copy(from: &Path, to: &Path) -> io::Result<u64> {
-    // FIXME: use with_native_path on all platforms
-    #[cfg(not(windows))]
-    return imp::copy(from, to);
-    #[cfg(windows)]
-    with_native_path(from, &|from| with_native_path(to, &|to| imp::copy(from, to)))
-}
-
-pub fn exists(path: &Path) -> io::Result<bool> {
-    // FIXME: use with_native_path on all platforms
-    #[cfg(not(windows))]
-    return imp::exists(path);
-    #[cfg(windows)]
-    with_native_path(path, &imp::exists)
-}
-
-pub fn set_times(path: &Path, times: FileTimes) -> io::Result<()> {
-    with_native_path(path, &|path| imp::set_times(path, times.clone()))
-}
-
-pub fn set_times_nofollow(path: &Path, times: FileTimes) -> io::Result<()> {
-    with_native_path(path, &|path| imp::set_times_nofollow(path, times.clone()))
-}

crates/std/src/sys/fs/unsupported.rs

@@ -1,362 +0,0 @@
-use crate::ffi::OsString;
-use crate::fmt;
-use crate::fs::TryLockError;
-use crate::hash::{Hash, Hasher};
-use crate::io::{self, BorrowedCursor, IoSlice, IoSliceMut, SeekFrom};
-use crate::path::{Path, PathBuf};
-pub use crate::sys::fs::common::Dir;
-use crate::sys::time::SystemTime;
-use crate::sys::unsupported;
-
-pub struct File(!);
-
-pub struct FileAttr(!);
-
-pub struct ReadDir(!);
-
-pub struct DirEntry(!);
-
-#[derive(Clone, Debug)]
-pub struct OpenOptions {}
-
-#[derive(Copy, Clone, Debug, Default)]
-pub struct FileTimes {}
-
-pub struct FilePermissions(!);
-
-pub struct FileType(!);
-
-#[derive(Debug)]
-pub struct DirBuilder {}
-
-impl FileAttr {
-    pub fn size(&self) -> u64 {
-        self.0
-    }
-
-    pub fn perm(&self) -> FilePermissions {
-        self.0
-    }
-
-    pub fn file_type(&self) -> FileType {
-        self.0
-    }
-
-    pub fn modified(&self) -> io::Result<SystemTime> {
-        self.0
-    }
-
-    pub fn accessed(&self) -> io::Result<SystemTime> {
-        self.0
-    }
-
-    pub fn created(&self) -> io::Result<SystemTime> {
-        self.0
-    }
-}
-
-impl Clone for FileAttr {
-    fn clone(&self) -> FileAttr {
-        self.0
-    }
-}
-
-impl FilePermissions {
-    pub fn readonly(&self) -> bool {
-        self.0
-    }
-
-    pub fn set_readonly(&mut self, _readonly: bool) {
-        self.0
-    }
-}
-
-impl Clone for FilePermissions {
-    fn clone(&self) -> FilePermissions {
-        self.0
-    }
-}
-
-impl PartialEq for FilePermissions {
-    fn eq(&self, _other: &FilePermissions) -> bool {
-        self.0
-    }
-}
-
-impl Eq for FilePermissions {}
-
-impl fmt::Debug for FilePermissions {
-    fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.0
-    }
-}
-
-impl FileTimes {
-    pub fn set_accessed(&mut self, _t: SystemTime) {}
-    pub fn set_modified(&mut self, _t: SystemTime) {}
-}
-
-impl FileType {
-    pub fn is_dir(&self) -> bool {
-        self.0
-    }
-
-    pub fn is_file(&self) -> bool {
-        self.0
-    }
-
-    pub fn is_symlink(&self) -> bool {
-        self.0
-    }
-}
-
-impl Clone for FileType {
-    fn clone(&self) -> FileType {
-        self.0
-    }
-}
-
-impl Copy for FileType {}
-
-impl PartialEq for FileType {
-    fn eq(&self, _other: &FileType) -> bool {
-        self.0
-    }
-}
-
-impl Eq for FileType {}
-
-impl Hash for FileType {
-    fn hash<H: Hasher>(&self, _h: &mut H) {
-        self.0
-    }
-}
-
-impl fmt::Debug for FileType {
-    fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.0
-    }
-}
-
-impl fmt::Debug for ReadDir {
-    fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.0
-    }
-}
-
-impl Iterator for ReadDir {
-    type Item = io::Result<DirEntry>;
-
-    fn next(&mut self) -> Option<io::Result<DirEntry>> {
-        self.0
-    }
-}
-
-impl DirEntry {
-    pub fn path(&self) -> PathBuf {
-        self.0
-    }
-
-    pub fn file_name(&self) -> OsString {
-        self.0
-    }
-
-    pub fn metadata(&self) -> io::Result<FileAttr> {
-        self.0
-    }
-
-    pub fn file_type(&self) -> io::Result<FileType> {
-        self.0
-    }
-}
-
-impl OpenOptions {
-    pub fn new() -> OpenOptions {
-        OpenOptions {}
-    }
-
-    pub fn read(&mut self, _read: bool) {}
-    pub fn write(&mut self, _write: bool) {}
-    pub fn append(&mut self, _append: bool) {}
-    pub fn truncate(&mut self, _truncate: bool) {}
-    pub fn create(&mut self, _create: bool) {}
-    pub fn create_new(&mut self, _create_new: bool) {}
-}
-
-impl File {
-    pub fn open(_path: &Path, _opts: &OpenOptions) -> io::Result<File> {
-        unsupported()
-    }
-
-    pub fn file_attr(&self) -> io::Result<FileAttr> {
-        self.0
-    }
-
-    pub fn fsync(&self) -> io::Result<()> {
-        self.0
-    }
-
-    pub fn datasync(&self) -> io::Result<()> {
-        self.0
-    }
-
-    pub fn lock(&self) -> io::Result<()> {
-        self.0
-    }
-
-    pub fn lock_shared(&self) -> io::Result<()> {
-        self.0
-    }
-
-    pub fn try_lock(&self) -> Result<(), TryLockError> {
-        self.0
-    }
-
-    pub fn try_lock_shared(&self) -> Result<(), TryLockError> {
-        self.0
-    }
-
-    pub fn unlock(&self) -> io::Result<()> {
-        self.0
-    }
-
-    pub fn truncate(&self, _size: u64) -> io::Result<()> {
-        self.0
-    }
-
-    pub fn read(&self, _buf: &mut [u8]) -> io::Result<usize> {
-        self.0
-    }
-
-    pub fn read_vectored(&self, _bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
-        self.0
-    }
-
-    pub fn is_read_vectored(&self) -> bool {
-        self.0
-    }
-
-    pub fn read_buf(&self, _cursor: BorrowedCursor<'_>) -> io::Result<()> {
-        self.0
-    }
-
-    pub fn write(&self, _buf: &[u8]) -> io::Result<usize> {
-        self.0
-    }
-
-    pub fn write_vectored(&self, _bufs: &[IoSlice<'_>]) -> io::Result<usize> {
-        self.0
-    }
-
-    pub fn is_write_vectored(&self) -> bool {
-        self.0
-    }
-
-    pub fn flush(&self) -> io::Result<()> {
-        self.0
-    }
-
-    pub fn seek(&self, _pos: SeekFrom) -> io::Result<u64> {
-        self.0
-    }
-
-    pub fn size(&self) -> Option<io::Result<u64>> {
-        self.0
-    }
-
-    pub fn tell(&self) -> io::Result<u64> {
-        self.0
-    }
-
-    pub fn duplicate(&self) -> io::Result<File> {
-        self.0
-    }
-
-    pub fn set_permissions(&self, _perm: FilePermissions) -> io::Result<()> {
-        self.0
-    }
-
-    pub fn set_times(&self, _times: FileTimes) -> io::Result<()> {
-        self.0
-    }
-}
-
-impl DirBuilder {
-    pub fn new() -> DirBuilder {
-        DirBuilder {}
-    }
-
-    pub fn mkdir(&self, _p: &Path) -> io::Result<()> {
-        unsupported()
-    }
-}
-
-impl fmt::Debug for File {
-    fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.0
-    }
-}
-
-pub fn readdir(_p: &Path) -> io::Result<ReadDir> {
-    unsupported()
-}
-
-pub fn unlink(_p: &Path) -> io::Result<()> {
-    unsupported()
-}
-
-pub fn rename(_old: &Path, _new: &Path) -> io::Result<()> {
-    unsupported()
-}
-
-pub fn set_perm(_p: &Path, perm: FilePermissions) -> io::Result<()> {
-    match perm.0 {}
-}
-
-pub fn set_times(_p: &Path, _times: FileTimes) -> io::Result<()> {
-    unsupported()
-}
-
-pub fn set_times_nofollow(_p: &Path, _times: FileTimes) -> io::Result<()> {
-    unsupported()
-}
-
-pub fn rmdir(_p: &Path) -> io::Result<()> {
-    unsupported()
-}
-
-pub fn remove_dir_all(_path: &Path) -> io::Result<()> {
-    unsupported()
-}
-
-pub fn exists(_path: &Path) -> io::Result<bool> {
-    unsupported()
-}
-
-pub fn readlink(_p: &Path) -> io::Result<PathBuf> {
-    unsupported()
-}
-
-pub fn symlink(_original: &Path, _link: &Path) -> io::Result<()> {
-    unsupported()
-}
-
-pub fn link(_src: &Path, _dst: &Path) -> io::Result<()> {
-    unsupported()
-}
-
-pub fn stat(_p: &Path) -> io::Result<FileAttr> {
-    unsupported()
-}
-
-pub fn lstat(_p: &Path) -> io::Result<FileAttr> {
-    unsupported()
-}
-
-pub fn canonicalize(_p: &Path) -> io::Result<PathBuf> {
-    unsupported()
-}
-
-pub fn copy(_from: &Path, _to: &Path) -> io::Result<u64> {
-    unsupported()
-}

crates/std/src/sys/mod.rs

@@ -1,36 +0,0 @@
-pub mod cmath;
-pub mod configure_builtins;
-pub mod env;
-pub mod env_consts;
-pub mod exit;
-pub mod os_str;
-pub mod path;
-pub mod sync;
-pub mod thread;
-pub mod time;
-pub mod random;
-pub mod thread_local;
-pub mod alloc;
-// pub mod fs;
-
-/// A trait for viewing representations from std types.
-#[cfg_attr(not(target_os = "linux"), allow(unused))]
-pub(crate) trait AsInner<Inner: ?Sized> {
-    fn as_inner(&self) -> &Inner;
-}
-
-/// A trait for viewing representations from std types.
-#[cfg_attr(not(target_os = "linux"), allow(unused))]
-pub(crate) trait AsInnerMut<Inner: ?Sized> {
-    fn as_inner_mut(&mut self) -> &mut Inner;
-}
-
-/// A trait for extracting representations from std types.
-pub(crate) trait IntoInner<Inner> {
-    fn into_inner(self) -> Inner;
-}
-
-/// A trait for creating std types from internal representations.
-pub(crate) trait FromInner<Inner> {
-    fn from_inner(inner: Inner) -> Self;
-}

crates/std/src/sys/os_str/bytes.rs

@@ -1,363 +0,0 @@
-//! The underlying OsString/OsStr implementation on Unix and many other
-//! systems: just a `Vec<u8>`/`[u8]`.
-
-use core::clone::CloneToUninit;
-
-use crate::borrow::Cow;
-use alloc_crate::bstr::ByteStr;
-use alloc_crate::collections::TryReserveError;
-use crate::rc::Rc;
-use alloc_crate::sync::Arc;
-use crate::sys::{AsInner, FromInner, IntoInner};
-use crate::{fmt, mem, str};
-
-#[cfg(test)]
-mod tests;
-
-#[derive(Hash)]
-#[repr(transparent)]
-pub struct Buf {
-    pub inner: Vec<u8>,
-}
-
-#[repr(transparent)]
-pub struct Slice {
-    pub inner: [u8],
-}
-
-impl IntoInner<Vec<u8>> for Buf {
-    fn into_inner(self) -> Vec<u8> {
-        self.inner
-    }
-}
-
-impl FromInner<Vec<u8>> for Buf {
-    fn from_inner(inner: Vec<u8>) -> Self {
-        Buf { inner }
-    }
-}
-
-impl AsInner<[u8]> for Buf {
-    #[inline]
-    fn as_inner(&self) -> &[u8] {
-        &self.inner
-    }
-}
-
-impl fmt::Debug for Buf {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt::Debug::fmt(self.as_slice(), f)
-    }
-}
-
-impl fmt::Display for Buf {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt::Display::fmt(self.as_slice(), f)
-    }
-}
-
-impl fmt::Debug for Slice {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt::Debug::fmt(&self.inner.utf8_chunks().debug(), f)
-    }
-}
-
-impl fmt::Display for Slice {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt::Display::fmt(ByteStr::new(&self.inner), f)
-    }
-}
-
-impl Clone for Buf {
-    #[inline]
-    fn clone(&self) -> Self {
-        Buf { inner: self.inner.clone() }
-    }
-
-    #[inline]
-    fn clone_from(&mut self, source: &Self) {
-        self.inner.clone_from(&source.inner)
-    }
-}
-
-impl Buf {
-    #[inline]
-    pub fn into_encoded_bytes(self) -> Vec<u8> {
-        self.inner
-    }
-
-    #[inline]
-    pub unsafe fn from_encoded_bytes_unchecked(s: Vec<u8>) -> Self {
-        Self { inner: s }
-    }
-
-    #[inline]
-    pub fn into_string(self) -> Result<String, Buf> {
-        String::from_utf8(self.inner).map_err(|p| Buf { inner: p.into_bytes() })
-    }
-
-    #[inline]
-    pub const fn from_string(s: String) -> Buf {
-        Buf { inner: s.into_bytes() }
-    }
-
-    #[inline]
-    pub fn with_capacity(capacity: usize) -> Buf {
-        Buf { inner: Vec::with_capacity(capacity) }
-    }
-
-    #[inline]
-    pub fn clear(&mut self) {
-        self.inner.clear()
-    }
-
-    #[inline]
-    pub fn capacity(&self) -> usize {
-        self.inner.capacity()
-    }
-
-    #[inline]
-    pub fn push_slice(&mut self, s: &Slice) {
-        self.inner.extend_from_slice(&s.inner)
-    }
-
-    #[inline]
-    pub fn push_str(&mut self, s: &str) {
-        self.inner.extend_from_slice(s.as_bytes());
-    }
-
-    #[inline]
-    pub fn reserve(&mut self, additional: usize) {
-        self.inner.reserve(additional)
-    }
-
-    #[inline]
-    pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError> {
-        self.inner.try_reserve(additional)
-    }
-
-    #[inline]
-    pub fn reserve_exact(&mut self, additional: usize) {
-        self.inner.reserve_exact(additional)
-    }
-
-    #[inline]
-    pub fn try_reserve_exact(&mut self, additional: usize) -> Result<(), TryReserveError> {
-        self.inner.try_reserve_exact(additional)
-    }
-
-    #[inline]
-    pub fn shrink_to_fit(&mut self) {
-        self.inner.shrink_to_fit()
-    }
-
-    #[inline]
-    pub fn shrink_to(&mut self, min_capacity: usize) {
-        self.inner.shrink_to(min_capacity)
-    }
-
-    #[inline]
-    pub fn as_slice(&self) -> &Slice {
-        // SAFETY: Slice is just a wrapper for [u8],
-        // and self.inner.as_slice() returns &[u8].
-        // Therefore, transmuting &[u8] to &Slice is safe.
-        unsafe { mem::transmute(self.inner.as_slice()) }
-    }
-
-    #[inline]
-    pub fn as_mut_slice(&mut self) -> &mut Slice {
-        // SAFETY: Slice is just a wrapper for [u8],
-        // and self.inner.as_mut_slice() returns &mut [u8].
-        // Therefore, transmuting &mut [u8] to &mut Slice is safe.
-        unsafe { mem::transmute(self.inner.as_mut_slice()) }
-    }
-
-    #[inline]
-    pub fn leak<'a>(self) -> &'a mut Slice {
-        unsafe { mem::transmute(self.inner.leak()) }
-    }
-
-    #[inline]
-    pub fn into_box(self) -> Box<Slice> {
-        unsafe { mem::transmute(self.inner.into_boxed_slice()) }
-    }
-
-    #[inline]
-    pub fn from_box(boxed: Box<Slice>) -> Buf {
-        let inner: Box<[u8]> = unsafe { mem::transmute(boxed) };
-        Buf { inner: inner.into_vec() }
-    }
-
-    #[inline]
-    pub fn into_arc(&self) -> Arc<Slice> {
-        self.as_slice().into_arc()
-    }
-
-    #[inline]
-    pub fn into_rc(&self) -> Rc<Slice> {
-        self.as_slice().into_rc()
-    }
-
-    /// Provides plumbing to `Vec::truncate` without giving full mutable access
-    /// to the `Vec`.
-    ///
-    /// # Safety
-    ///
-    /// The length must be at an `OsStr` boundary, according to
-    /// `Slice::check_public_boundary`.
-    #[inline]
-    pub unsafe fn truncate_unchecked(&mut self, len: usize) {
-        self.inner.truncate(len);
-    }
-
-    /// Provides plumbing to `Vec::extend_from_slice` without giving full
-    /// mutable access to the `Vec`.
-    ///
-    /// # Safety
-    ///
-    /// The slice must be valid for the platform encoding (as described in
-    /// `OsStr::from_encoded_bytes_unchecked`). This encoding has no safety
-    /// requirements.
-    #[inline]
-    pub unsafe fn extend_from_slice_unchecked(&mut self, other: &[u8]) {
-        self.inner.extend_from_slice(other);
-    }
-}
-
-impl Slice {
-    #[inline]
-    pub fn as_encoded_bytes(&self) -> &[u8] {
-        &self.inner
-    }
-
-    #[inline]
-    pub unsafe fn from_encoded_bytes_unchecked(s: &[u8]) -> &Slice {
-        unsafe { mem::transmute(s) }
-    }
-
-    #[track_caller]
-    #[inline]
-    pub fn check_public_boundary(&self, index: usize) {
-        if index == 0 || index == self.inner.len() {
-            return;
-        }
-        if index < self.inner.len()
-            && (self.inner[index - 1].is_ascii() || self.inner[index].is_ascii())
-        {
-            return;
-        }
-
-        slow_path(&self.inner, index);
-
-        /// We're betting that typical splits will involve an ASCII character.
-        ///
-        /// Putting the expensive checks in a separate function generates notably
-        /// better assembly.
-        #[track_caller]
-        #[inline(never)]
-        fn slow_path(bytes: &[u8], index: usize) {
-            let (before, after) = bytes.split_at(index);
-
-            // UTF-8 takes at most 4 bytes per codepoint, so we don't
-            // need to check more than that.
-            let after = after.get(..4).unwrap_or(after);
-            match str::from_utf8(after) {
-                Ok(_) => return,
-                Err(err) if err.valid_up_to() != 0 => return,
-                Err(_) => (),
-            }
-
-            for len in 2..=4.min(index) {
-                let before = &before[index - len..];
-                if str::from_utf8(before).is_ok() {
-                    return;
-                }
-            }
-
-            panic!("byte index {index} is not an OsStr boundary");
-        }
-    }
-
-    #[inline]
-    pub fn from_str(s: &str) -> &Slice {
-        unsafe { Slice::from_encoded_bytes_unchecked(s.as_bytes()) }
-    }
-
-    #[inline]
-    pub fn to_str(&self) -> Result<&str, crate::str::Utf8Error> {
-        str::from_utf8(&self.inner)
-    }
-
-    #[inline]
-    pub fn to_string_lossy(&self) -> Cow<'_, str> {
-        String::from_utf8_lossy(&self.inner)
-    }
-
-    #[inline]
-    pub fn to_owned(&self) -> Buf {
-        Buf { inner: self.inner.to_vec() }
-    }
-
-    #[inline]
-    pub fn clone_into(&self, buf: &mut Buf) {
-        self.inner.clone_into(&mut buf.inner)
-    }
-
-    #[inline]
-    pub fn empty_box() -> Box<Slice> {
-        let boxed: Box<[u8]> = Default::default();
-        unsafe { mem::transmute(boxed) }
-    }
-
-    #[inline]
-    pub fn into_arc(&self) -> Arc<Slice> {
-        let arc: Arc<[u8]> = Arc::from(&self.inner);
-        unsafe { Arc::from_raw(Arc::into_raw(arc) as *const Slice) }
-    }
-
-    #[inline]
-    pub fn into_rc(&self) -> Rc<Slice> {
-        let rc: Rc<[u8]> = Rc::from(&self.inner);
-        unsafe { Rc::from_raw(Rc::into_raw(rc) as *const Slice) }
-    }
-
-    #[inline]
-    pub fn make_ascii_lowercase(&mut self) {
-        self.inner.make_ascii_lowercase()
-    }
-
-    #[inline]
-    pub fn make_ascii_uppercase(&mut self) {
-        self.inner.make_ascii_uppercase()
-    }
-
-    #[inline]
-    pub fn to_ascii_lowercase(&self) -> Buf {
-        Buf { inner: self.inner.to_ascii_lowercase() }
-    }
-
-    #[inline]
-    pub fn to_ascii_uppercase(&self) -> Buf {
-        Buf { inner: self.inner.to_ascii_uppercase() }
-    }
-
-    #[inline]
-    pub fn is_ascii(&self) -> bool {
-        self.inner.is_ascii()
-    }
-
-    #[inline]
-    pub fn eq_ignore_ascii_case(&self, other: &Self) -> bool {
-        self.inner.eq_ignore_ascii_case(&other.inner)
-    }
-}
-
-#[unstable(feature = "clone_to_uninit", issue = "126799")]
-unsafe impl CloneToUninit for Slice {
-    #[inline]
-    #[cfg_attr(debug_assertions, track_caller)]
-    unsafe fn clone_to_uninit(&self, dst: *mut u8) {
-        // SAFETY: we're just a transparent wrapper around [u8]
-        unsafe { self.inner.clone_to_uninit(dst) }
-    }
-}

crates/std/src/sys/os_str/bytes/tests.rs

@@ -1,17 +0,0 @@
-use super::*;
-
-#[test]
-fn slice_debug_output() {
-    let input = unsafe { Slice::from_encoded_bytes_unchecked(b"\xF0hello,\tworld") };
-    let expected = r#""\xF0hello,\tworld""#;
-    let output = format!("{input:?}");
-
-    assert_eq!(output, expected);
-}
-
-#[test]
-fn display() {
-    assert_eq!("Hello\u{FFFD}\u{FFFD} There\u{FFFD} Goodbye", unsafe {
-        Slice::from_encoded_bytes_unchecked(b"Hello\xC0\x80 There\xE6\x83 Goodbye").to_string()
-    },);
-}

crates/std/src/sys/os_str/mod.rs

@@ -1,16 +0,0 @@
-#![forbid(unsafe_op_in_unsafe_fn)]
-
-cfg_select! {
-    any(target_os = "windows", target_os = "uefi") => {
-        mod wtf8;
-        pub use wtf8::{Buf, Slice};
-    }
-    any(target_os = "motor") => {
-        mod utf8;
-        pub use utf8::{Buf, Slice};
-    }
-    _ => {
-        mod bytes;
-        pub use bytes::{Buf, Slice};
-    }
-}

crates/std/src/sys/path/mod.rs

@@ -1,28 +0,0 @@
-cfg_select! {
-    target_os = "windows" => {
-        mod windows;
-        mod windows_prefix;
-        pub use windows::*;
-    }
-    all(target_vendor = "fortanix", target_env = "sgx") => {
-        mod sgx;
-        pub use sgx::*;
-    }
-    target_os = "solid_asp3" => {
-        mod unsupported_backslash;
-        pub use unsupported_backslash::*;
-    }
-    target_os = "uefi" => {
-        mod uefi;
-        pub use uefi::*;
-    }
-    target_os = "cygwin" => {
-        mod cygwin;
-        mod windows_prefix;
-        pub use cygwin::*;
-    }
-    _ => {
-        mod unix;
-        pub use unix::*;
-    }
-}

crates/std/src/sys/path/unix.rs

@@ -1,72 +0,0 @@
-use crate::ffi::OsStr;
-use crate::path::{Path, PathBuf, Prefix};
-use crate::{env, io};
-
-#[inline]
-pub fn is_sep_byte(b: u8) -> bool {
-    b == b'/'
-}
-
-#[inline]
-pub fn is_verbatim_sep(b: u8) -> bool {
-    b == b'/'
-}
-
-#[inline]
-pub fn parse_prefix(_: &OsStr) -> Option<Prefix<'_>> {
-    None
-}
-
-pub const HAS_PREFIXES: bool = false;
-pub const MAIN_SEP_STR: &str = "/";
-pub const MAIN_SEP: char = '/';
-
-/// Make a POSIX path absolute without changing its semantics.
-pub(crate) fn absolute(path: &Path) -> io::Result<PathBuf> {
-    // This is mostly a wrapper around collecting `Path::components`, with
-    // exceptions made where this conflicts with the POSIX specification.
-    // See 4.13 Pathname Resolution, IEEE Std 1003.1-2017
-    // https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap04.html#tag_04_13
-
-    // Get the components, skipping the redundant leading "." component if it exists.
-    let mut components = path.strip_prefix(".").unwrap_or(path).components();
-    let path_os = path.as_os_str().as_encoded_bytes();
-
-    let mut normalized = if path.is_absolute() {
-        // "If a pathname begins with two successive <slash> characters, the
-        // first component following the leading <slash> characters may be
-        // interpreted in an implementation-defined manner, although more than
-        // two leading <slash> characters shall be treated as a single <slash>
-        // character."
-        if path_os.starts_with(b"//") && !path_os.starts_with(b"///") {
-            components.next();
-            PathBuf::from("//")
-        } else {
-            PathBuf::new()
-        }
-    } else {
-        // env::current_dir()?
-        todo!()
-    };
-    normalized.extend(components);
-
-    // "Interfaces using pathname resolution may specify additional constraints
-    // when a pathname that does not name an existing directory contains at
-    // least one non- <slash> character and contains one or more trailing
-    // <slash> characters".
-    // A trailing <slash> is also meaningful if "a symbolic link is
-    // encountered during pathname resolution".
-    if path_os.ends_with(b"/") {
-        normalized.push("");
-    }
-
-    Ok(normalized)
-}
-
-pub(crate) fn is_absolute(path: &Path) -> bool {
-    if cfg!(any(unix, target_os = "hermit", target_os = "wasi", target_os = "motor")) {
-        path.has_root()
-    } else {
-        path.has_root() && path.prefix().is_some()
-    }
-}

crates/std/src/sys/random/mod.rs

@@ -1,134 +0,0 @@
-cfg_select! {
-    // Tier 1
-    any(target_os = "linux", target_os = "android") => {
-        mod linux;
-        pub use linux::{fill_bytes, hashmap_random_keys};
-    }
-    target_os = "windows" => {
-        mod windows;
-        pub use windows::fill_bytes;
-    }
-    target_vendor = "apple" => {
-        mod apple;
-        pub use apple::fill_bytes;
-    // Others, in alphabetical ordering.
-    }
-    any(
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "rtems",
-        target_os = "solaris",
-        target_os = "vita",
-        target_os = "nuttx",
-    ) => {
-        mod arc4random;
-        pub use arc4random::fill_bytes;
-    }
-    target_os = "emscripten" => {
-        mod getentropy;
-        pub use getentropy::fill_bytes;
-    }
-    target_os = "espidf" => {
-        mod espidf;
-        pub use espidf::fill_bytes;
-    }
-    target_os = "fuchsia" => {
-        mod fuchsia;
-        pub use fuchsia::fill_bytes;
-    }
-    target_os = "hermit" => {
-        mod hermit;
-        pub use hermit::fill_bytes;
-    }
-    any(target_os = "horizon", target_os = "cygwin") => {
-        // FIXME(horizon): add arc4random_buf to shim-3ds
-        mod getrandom;
-        pub use getrandom::fill_bytes;
-    }
-    any(
-        target_os = "aix",
-        target_os = "hurd",
-        target_os = "l4re",
-        target_os = "nto",
-    ) => {
-        mod unix_legacy;
-        pub use unix_legacy::fill_bytes;
-    }
-    target_os = "redox" => {
-        mod redox;
-        pub use redox::fill_bytes;
-    }
-    target_os = "motor" => {
-        mod motor;
-        pub use motor::fill_bytes;
-    }
-    all(target_vendor = "fortanix", target_env = "sgx") => {
-        mod sgx;
-        pub use sgx::fill_bytes;
-    }
-    target_os = "solid_asp3" => {
-        mod solid;
-        pub use solid::fill_bytes;
-    }
-    target_os = "teeos" => {
-        mod teeos;
-        pub use teeos::fill_bytes;
-    }
-    target_os = "trusty" => {
-        mod trusty;
-        pub use trusty::fill_bytes;
-    }
-    target_os = "uefi" => {
-        mod uefi;
-        pub use uefi::fill_bytes;
-    }
-    target_os = "vxworks" => {
-        mod vxworks;
-        pub use vxworks::fill_bytes;
-    }
-    all(target_os = "wasi", target_env = "p1") => {
-        mod wasip1;
-        pub use wasip1::fill_bytes;
-    }
-    all(target_os = "wasi", any(target_env = "p2", target_env = "p3")) => {
-        mod wasip2;
-        pub use wasip2::{fill_bytes, hashmap_random_keys};
-    }
-    target_os = "zkvm" => {
-        mod zkvm;
-        pub use zkvm::fill_bytes;
-    }
-    any(
-        all(target_family = "wasm", target_os = "unknown"),
-        target_os = "xous",
-        target_os = "vexos",
-target_os = "survos",
-    ) => {
-        // FIXME: finally remove std support for wasm32-unknown-unknown
-        // FIXME: add random data generation to xous
-        mod unsupported;
-        pub use unsupported::{fill_bytes, hashmap_random_keys};
-    }
-    _ => {}
-}
-
-#[cfg(not(any(
-    target_os = "linux",
-    target_os = "android",
-    all(target_family = "wasm", target_os = "unknown"),
-    all(target_os = "wasi", not(target_env = "p1")),
-    target_os = "xous",
-    target_os = "vexos",
-target_os = "survos",
-)))]
-pub fn hashmap_random_keys() -> (u64, u64) {
-    let mut buf = [0; 16];
-    fill_bytes(&mut buf);
-    let k1 = u64::from_ne_bytes(buf[..8].try_into().unwrap());
-    let k2 = u64::from_ne_bytes(buf[8..].try_into().unwrap());
-    (k1, k2)
-}

crates/std/src/sys/random/unsupported.rs

@@ -1,15 +0,0 @@
-use crate::ptr;
-
-pub fn fill_bytes(_: &mut [u8]) {
-    panic!("this target does not support random data generation");
-}
-
-pub fn hashmap_random_keys() -> (u64, u64) {
-    // Use allocation addresses for a bit of randomness. This isn't
-    // particularly secure, but there isn't really an alternative.
-    let stack = 0u8;
-    let heap = Box::new(0u8);
-    let k1 = ptr::from_ref(&stack).addr() as u64;
-    let k2 = ptr::from_ref(&*heap).addr() as u64;
-    (k1, k2)
-}

crates/std/src/sys/sync/condvar/mod.rs

@@ -1,44 +0,0 @@
-cfg_select! {
-    any(
-        all(target_os = "windows", not(target_vendor="win7")),
-        target_os = "linux",
-        target_os = "android",
-        target_os = "freebsd",
-        target_os = "openbsd",
-        target_os = "dragonfly",
-        target_os = "motor",
-        target_os = "fuchsia",
-        all(target_family = "wasm", target_feature = "atomics"),
-        target_os = "hermit",
-    ) => {
-        mod futex;
-        pub use futex::Condvar;
-    }
-    any(
-        target_family = "unix",
-        target_os = "teeos",
-    ) => {
-        mod pthread;
-        pub use pthread::Condvar;
-    }
-    all(target_os = "windows", target_vendor = "win7") => {
-        mod windows7;
-        pub use windows7::Condvar;
-    }
-    all(target_vendor = "fortanix", target_env = "sgx") => {
-        mod sgx;
-        pub use sgx::Condvar;
-    }
-    target_os = "solid_asp3" => {
-        mod itron;
-        pub use itron::Condvar;
-    }
-    target_os = "xous" => {
-        mod xous;
-        pub use xous::Condvar;
-    }
-    _ => {
-        mod no_threads;
-        pub use no_threads::Condvar;
-    }
-}

crates/std/src/sys/sync/condvar/no_threads.rs

@@ -1,27 +0,0 @@
-use crate::sys::sync::Mutex;
-use crate::thread::sleep;
-use crate::time::Duration;
-
-pub struct Condvar {}
-
-impl Condvar {
-    #[inline]
-    pub const fn new() -> Condvar {
-        Condvar {}
-    }
-
-    #[inline]
-    pub fn notify_one(&self) {}
-
-    #[inline]
-    pub fn notify_all(&self) {}
-
-    pub unsafe fn wait(&self, _mutex: &Mutex) {
-        panic!("condvar wait not supported")
-    }
-
-    pub unsafe fn wait_timeout(&self, _mutex: &Mutex, dur: Duration) -> bool {
-        sleep(dur);
-        false
-    }
-}

crates/std/src/sys/sync/mod.rs

@@ -1,9 +0,0 @@
-mod condvar;
-mod mutex;
-mod once;
-mod rwlock;
-
-pub use condvar::Condvar;
-pub use mutex::Mutex;
-pub use once::{Once, OnceState};
-pub use rwlock::RwLock;

crates/std/src/sys/sync/mutex/mod.rs

@@ -1,47 +0,0 @@
-cfg_select! {
-    any(
-        all(target_os = "windows", not(target_vendor = "win7")),
-        target_os = "linux",
-        target_os = "android",
-        target_os = "freebsd",
-        target_os = "openbsd",
-        target_os = "motor",
-        target_os = "dragonfly",
-        all(target_family = "wasm", target_feature = "atomics"),
-        target_os = "hermit",
-    ) => {
-        mod futex;
-        pub use futex::Mutex;
-    }
-    target_os = "fuchsia" => {
-        mod fuchsia;
-        pub use fuchsia::Mutex;
-    }
-    any(
-        target_family = "unix",
-        target_os = "teeos",
-    ) => {
-        mod pthread;
-        pub use pthread::Mutex;
-    }
-    all(target_os = "windows", target_vendor = "win7") => {
-        mod windows7;
-        pub use windows7::{Mutex, raw};
-    }
-    all(target_vendor = "fortanix", target_env = "sgx") => {
-        mod sgx;
-        pub use sgx::Mutex;
-    }
-    target_os = "solid_asp3" => {
-        mod itron;
-        pub use itron::Mutex;
-    }
-    target_os = "xous" => {
-        mod xous;
-        pub use xous::Mutex;
-    }
-    _ => {
-        mod no_threads;
-        pub use no_threads::Mutex;
-    }
-}

crates/std/src/sys/sync/mutex/no_threads.rs

@@ -1,31 +0,0 @@
-use crate::cell::Cell;
-
-pub struct Mutex {
-    // This platform has no threads, so we can use a Cell here.
-    locked: Cell<bool>,
-}
-
-unsafe impl Send for Mutex {}
-unsafe impl Sync for Mutex {} // no threads on this platform
-
-impl Mutex {
-    #[inline]
-    pub const fn new() -> Mutex {
-        Mutex { locked: Cell::new(false) }
-    }
-
-    #[inline]
-    pub fn lock(&self) {
-        assert_eq!(self.locked.replace(true), false, "cannot recursively acquire mutex");
-    }
-
-    #[inline]
-    pub unsafe fn unlock(&self) {
-        self.locked.set(false);
-    }
-
-    #[inline]
-    pub fn try_lock(&self) -> bool {
-        self.locked.replace(true) == false
-    }
-}

crates/std/src/sys/sync/once/mod.rs

@@ -1,40 +0,0 @@
-// A "once" is a relatively simple primitive, and it's also typically provided
-// by the OS as well (see `pthread_once` or `InitOnceExecuteOnce`). The OS
-// primitives, however, tend to have surprising restrictions, such as the Unix
-// one doesn't allow an argument to be passed to the function.
-//
-// As a result, we end up implementing it ourselves in the standard library.
-// This also gives us the opportunity to optimize the implementation a bit which
-// should help the fast path on call sites.
-
-cfg_select! {
-    any(
-        all(target_os = "windows", not(target_vendor="win7")),
-        target_os = "linux",
-        target_os = "android",
-        all(target_arch = "wasm32", target_feature = "atomics"),
-        target_os = "freebsd",
-        target_os = "motor",
-        target_os = "openbsd",
-        target_os = "dragonfly",
-        target_os = "fuchsia",
-        target_os = "hermit",
-    ) => {
-        mod futex;
-        pub use futex::{Once, OnceState};
-    }
-    any(
-        windows,
-        target_family = "unix",
-        all(target_vendor = "fortanix", target_env = "sgx"),
-        target_os = "solid_asp3",
-        target_os = "xous",
-    ) => {
-        mod queue;
-        pub use queue::{Once, OnceState};
-    }
-    _ => {
-        mod no_threads;
-        pub use no_threads::{Once, OnceState};
-    }
-}

crates/std/src/sys/sync/once/no_threads.rs

@@ -1,114 +0,0 @@
-use crate::cell::Cell;
-use crate::sync as public;
-use crate::sync::once::OnceExclusiveState;
-
-pub struct Once {
-    state: Cell<State>,
-}
-
-pub struct OnceState {
-    poisoned: bool,
-    set_state_to: Cell<State>,
-}
-
-#[derive(Clone, Copy, PartialEq, Eq)]
-enum State {
-    Incomplete,
-    Poisoned,
-    Running,
-    Complete,
-}
-
-struct CompletionGuard<'a> {
-    state: &'a Cell<State>,
-    set_state_on_drop_to: State,
-}
-
-impl<'a> Drop for CompletionGuard<'a> {
-    fn drop(&mut self) {
-        self.state.set(self.set_state_on_drop_to);
-    }
-}
-
-// Safety: threads are not supported on this platform.
-unsafe impl Sync for Once {}
-
-impl Once {
-    #[inline]
-    pub const fn new() -> Once {
-        Once { state: Cell::new(State::Incomplete) }
-    }
-
-    #[inline]
-    pub fn is_completed(&self) -> bool {
-        self.state.get() == State::Complete
-    }
-
-    #[inline]
-    pub(crate) fn state(&mut self) -> OnceExclusiveState {
-        match self.state.get() {
-            State::Incomplete => OnceExclusiveState::Incomplete,
-            State::Poisoned => OnceExclusiveState::Poisoned,
-            State::Complete => OnceExclusiveState::Complete,
-            _ => unreachable!("invalid Once state"),
-        }
-    }
-
-    #[inline]
-    pub(crate) fn set_state(&mut self, new_state: OnceExclusiveState) {
-        self.state.set(match new_state {
-            OnceExclusiveState::Incomplete => State::Incomplete,
-            OnceExclusiveState::Poisoned => State::Poisoned,
-            OnceExclusiveState::Complete => State::Complete,
-        });
-    }
-
-    #[cold]
-    #[track_caller]
-    pub fn wait(&self, _ignore_poisoning: bool) {
-        panic!("not implementable on this target");
-    }
-
-    #[cold]
-    #[track_caller]
-    pub fn call(&self, ignore_poisoning: bool, f: &mut impl FnMut(&public::OnceState)) {
-        let state = self.state.get();
-        match state {
-            State::Poisoned if !ignore_poisoning => {
-                // Panic to propagate the poison.
-                panic!("Once instance has previously been poisoned");
-            }
-            State::Incomplete | State::Poisoned => {
-                self.state.set(State::Running);
-                // `guard` will set the new state on drop.
-                let mut guard =
-                    CompletionGuard { state: &self.state, set_state_on_drop_to: State::Poisoned };
-                // Run the function, letting it know if we're poisoned or not.
-                let f_state = public::OnceState {
-                    inner: OnceState {
-                        poisoned: state == State::Poisoned,
-                        set_state_to: Cell::new(State::Complete),
-                    },
-                };
-                f(&f_state);
-                guard.set_state_on_drop_to = f_state.inner.set_state_to.get();
-            }
-            State::Running => {
-                panic!("one-time initialization may not be performed recursively");
-            }
-            State::Complete => {}
-        }
-    }
-}
-
-impl OnceState {
-    #[inline]
-    pub fn is_poisoned(&self) -> bool {
-        self.poisoned
-    }
-
-    #[inline]
-    pub fn poison(&self) {
-        self.set_state_to.set(State::Poisoned)
-    }
-}

crates/std/src/sys/sync/rwlock/mod.rs

@@ -1,35 +0,0 @@
-cfg_select! {
-    any(
-        all(target_os = "windows", not(target_vendor = "win7")),
-        target_os = "linux",
-        target_os = "android",
-        target_os = "freebsd",
-        target_os = "openbsd",
-        target_os = "dragonfly",
-        target_os = "fuchsia",
-        all(target_family = "wasm", target_feature = "atomics"),
-        target_os = "hermit",
-       target_os = "motor",
-    ) => {
-        mod futex;
-        pub use futex::RwLock;
-    }
-    any(
-        target_family = "unix",
-        all(target_os = "windows", target_vendor = "win7"),
-        all(target_vendor = "fortanix", target_env = "sgx"),
-        target_os = "xous",
-        target_os = "teeos",
-    ) => {
-        mod queue;
-        pub use queue::RwLock;
-    }
-    target_os = "solid_asp3" => {
-        mod solid;
-        pub use solid::RwLock;
-    }
-    _ => {
-        mod no_threads;
-        pub use no_threads::RwLock;
-    }
-}

crates/std/src/sys/sync/rwlock/no_threads.rs

@@ -1,69 +0,0 @@
-use crate::cell::Cell;
-
-pub struct RwLock {
-    // This platform has no threads, so we can use a Cell here.
-    mode: Cell<isize>,
-}
-
-unsafe impl Send for RwLock {}
-unsafe impl Sync for RwLock {} // no threads on this platform
-
-impl RwLock {
-    #[inline]
-    pub const fn new() -> RwLock {
-        RwLock { mode: Cell::new(0) }
-    }
-
-    #[inline]
-    pub fn read(&self) {
-        let m = self.mode.get();
-        if m >= 0 {
-            self.mode.set(m + 1);
-        } else {
-            rtabort!("rwlock locked for writing");
-        }
-    }
-
-    #[inline]
-    pub fn try_read(&self) -> bool {
-        let m = self.mode.get();
-        if m >= 0 {
-            self.mode.set(m + 1);
-            true
-        } else {
-            false
-        }
-    }
-
-    #[inline]
-    pub fn write(&self) {
-        if self.mode.replace(-1) != 0 {
-            rtabort!("rwlock locked for reading")
-        }
-    }
-
-    #[inline]
-    pub fn try_write(&self) -> bool {
-        if self.mode.get() == 0 {
-            self.mode.set(-1);
-            true
-        } else {
-            false
-        }
-    }
-
-    #[inline]
-    pub unsafe fn read_unlock(&self) {
-        self.mode.set(self.mode.get() - 1);
-    }
-
-    #[inline]
-    pub unsafe fn write_unlock(&self) {
-        assert_eq!(self.mode.replace(0), -1);
-    }
-
-    #[inline]
-    pub unsafe fn downgrade(&self) {
-        assert_eq!(self.mode.replace(1), -1);
-    }
-}

crates/std/src/sys/thread/mod.rs

@@ -1,154 +0,0 @@
-cfg_select! {
-    target_os = "hermit" => {
-        mod hermit;
-        pub use hermit::{Thread, available_parallelism, sleep, yield_now, DEFAULT_MIN_STACK_SIZE};
-        #[expect(dead_code)]
-        mod unsupported;
-        pub use unsupported::{current_os_id, set_name};
-    }
-    target_os = "motor" => {
-        mod motor;
-        pub use motor::*;
-    }
-    all(target_vendor = "fortanix", target_env = "sgx") => {
-        mod sgx;
-        pub use sgx::{Thread, current_os_id, sleep, yield_now, DEFAULT_MIN_STACK_SIZE};
-
-        // SGX should protect in-enclave data from outside attackers, so there
-        // must not be any data leakage to the OS, particularly no 1-1 mapping
-        // between SGX thread names and OS thread names. Hence `set_name` is
-        // intentionally a no-op.
-        //
-        // Note that the internally visible SGX thread name is already provided
-        // by the platform-agnostic Rust thread code. This can be observed in
-        // the [`std::thread::tests::test_named_thread`] test, which succeeds
-        // as-is with the SGX target.
-        #[expect(dead_code)]
-        mod unsupported;
-        pub use unsupported::{available_parallelism, set_name};
-    }
-    target_os = "solid_asp3" => {
-        mod solid;
-        pub use solid::{Thread, sleep, yield_now, DEFAULT_MIN_STACK_SIZE};
-        #[expect(dead_code)]
-        mod unsupported;
-        pub use unsupported::{available_parallelism, current_os_id, set_name};
-    }
-    target_os = "teeos" => {
-        mod teeos;
-        pub use teeos::{Thread, sleep, yield_now, DEFAULT_MIN_STACK_SIZE};
-        #[expect(dead_code)]
-        mod unsupported;
-        pub use unsupported::{available_parallelism, current_os_id, set_name};
-    }
-    target_os = "uefi" => {
-        mod uefi;
-        pub use uefi::{available_parallelism, sleep};
-        #[expect(dead_code)]
-        mod unsupported;
-        pub use unsupported::{Thread, current_os_id, set_name, yield_now, DEFAULT_MIN_STACK_SIZE};
-    }
-    any(target_family = "unix", target_os = "wasi") => {
-        mod unix;
-        pub use unix::{Thread, available_parallelism, current_os_id, sleep, yield_now, DEFAULT_MIN_STACK_SIZE};
-        #[cfg(not(any(
-            target_env = "newlib",
-            target_os = "l4re",
-            target_os = "emscripten",
-            target_os = "redox",
-            target_os = "hurd",
-            target_os = "aix",
-            target_os = "wasi",
-        )))]
-        pub use unix::set_name;
-        #[cfg(any(
-            target_os = "freebsd",
-            target_os = "netbsd",
-            target_os = "linux",
-            target_os = "android",
-            target_os = "solaris",
-            target_os = "illumos",
-            target_os = "dragonfly",
-            target_os = "hurd",
-            target_os = "vxworks",
-            target_os = "wasi",
-            target_vendor = "apple",
-        ))]
-        pub use unix::sleep_until;
-        #[expect(dead_code)]
-        mod unsupported;
-        #[cfg(any(
-            target_env = "newlib",
-            target_os = "l4re",
-            target_os = "emscripten",
-            target_os = "redox",
-            target_os = "hurd",
-            target_os = "aix",
-            target_os = "wasi",
-        ))]
-        pub use unsupported::set_name;
-    }
-    target_os = "vexos" => {
-        mod vexos;
-        pub use vexos::{sleep, sleep_until, yield_now};
-        #[expect(dead_code)]
-        mod unsupported;
-        pub use unsupported::{Thread, available_parallelism, current_os_id, set_name, DEFAULT_MIN_STACK_SIZE};
-    }
-    all(target_family = "wasm", target_feature = "atomics") => {
-        mod wasm;
-        pub use wasm::sleep;
-
-        #[expect(dead_code)]
-        mod unsupported;
-        pub use unsupported::{Thread, available_parallelism, current_os_id, set_name, yield_now, DEFAULT_MIN_STACK_SIZE};
-    }
-    target_os = "windows" => {
-        mod windows;
-        pub use windows::{Thread, available_parallelism, current_os_id, set_name, set_name_wide, sleep, yield_now, DEFAULT_MIN_STACK_SIZE};
-    }
-    target_os = "xous" => {
-        mod xous;
-        pub use xous::{Thread, available_parallelism, sleep, yield_now, DEFAULT_MIN_STACK_SIZE};
-
-        #[expect(dead_code)]
-        mod unsupported;
-        pub use unsupported::{current_os_id, set_name};
-    }
-    _ => {
-        mod unsupported;
-        pub use unsupported::{Thread, available_parallelism, current_os_id, set_name, sleep, yield_now, DEFAULT_MIN_STACK_SIZE};
-    }
-}
-
-#[cfg(not(any(
-    target_os = "freebsd",
-    target_os = "netbsd",
-    target_os = "linux",
-    target_os = "android",
-    target_os = "solaris",
-    target_os = "illumos",
-    target_os = "dragonfly",
-    target_os = "hurd",
-    target_os = "vxworks",
-    target_os = "wasi",
-    target_vendor = "apple",
-    target_os = "motor",
-    target_os = "vexos"
-)))]
-pub fn sleep_until(deadline: crate::time::Instant) {
-    use crate::time::Instant;
-
-    // The clock source used for `sleep` might not be the same used for `Instant`.
-    // Since this function *must not* return before the deadline, we recheck the
-    // time after every call to `sleep`. See #149935 for an example of this
-    // occurring on older Windows systems.
-    while let Some(delay) = deadline.checked_duration_since(Instant::now()) {
-        // Sleep for the estimated time remaining until the deadline.
-        //
-        // If your system has a better way of estimating the delay time or
-        // provides a way to sleep until an absolute time, specialize this
-        // function for your system.
-        sleep(delay);
-    }
-}

crates/std/src/sys/thread/unsupported.rs

@@ -1,46 +0,0 @@
-use crate::ffi::CStr;
-use crate::io;
-use crate::num::NonZero;
-use crate::thread::ThreadInit;
-use crate::time::Duration;
-
-// Silence dead code warnings for the otherwise unused ThreadInit::init() call.
-#[expect(dead_code)]
-fn dummy_init_call(init: Box<ThreadInit>) {
-    drop(init.init());
-}
-
-pub struct Thread(!);
-
-pub const DEFAULT_MIN_STACK_SIZE: usize = 64 * 1024;
-
-impl Thread {
-    // unsafe: see thread::Builder::spawn_unchecked for safety requirements
-    pub unsafe fn new(_stack: usize, _init: Box<ThreadInit>) -> io::Result<Thread> {
-        Err(io::Error::UNSUPPORTED_PLATFORM)
-    }
-
-    pub fn join(self) {
-        self.0
-    }
-}
-
-pub fn available_parallelism() -> io::Result<NonZero<usize>> {
-    Err(io::Error::UNKNOWN_THREAD_COUNT)
-}
-
-pub fn current_os_id() -> Option<u64> {
-    None
-}
-
-pub fn yield_now() {
-    // do nothing
-}
-
-pub fn set_name(_name: &CStr) {
-    // nope
-}
-
-pub fn sleep(_dur: Duration) {
-    panic!("can't sleep");
-}