languages/rust
languages/rust
1
0
Fork 0
mirror of https://github.com/rust-lang/rust synced 2024-10-01 14:25:08 +00:00
Code Issues Packages Projects Releases Wiki Activity

Auto merge of #123732 - a1phyr:io_error_factor, r=cuviper

Browse source 
Factor some common `io::Error` constants
This commit is contained in:
bors 2024-04-11 17:49:04 +00:00
parent df7daa815f 9c64068ddb
commit aa6a697a1c
21 changed files with 67 additions and 159 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
library/std/src/io/buffered/bufreader.rs
View file

@ -383,12 +383,7 @@ fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> {
// buffer.
let mut bytes = Vec::new();
self.read_to_end(&mut bytes)?;
let string = crate::str::from_utf8(&bytes).map_err(|_| {
io::const_io_error!(
io::ErrorKind::InvalidData,
"stream did not contain valid UTF-8",
)
})?;
let string = crate::str::from_utf8(&bytes).map_err(|_| io::Error::INVALID_UTF8)?;
*buf += string;
Ok(string.len())
}

24
library/std/src/io/error.rs
View file

@ -75,6 +75,30 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
}
}
/// Common errors constants for use in std
#[allow(dead_code)]
impl Error {
pub(crate) const INVALID_UTF8: Self =
const_io_error!(ErrorKind::InvalidData, "stream did not contain valid UTF-8");
pub(crate) const READ_EXACT_EOF: Self =
const_io_error!(ErrorKind::UnexpectedEof, "failed to fill whole buffer");
pub(crate) const UNKNOWN_THREAD_COUNT: Self = const_io_error!(
ErrorKind::NotFound,
"The number of hardware threads is not known for the target platform"
);
pub(crate) const UNSUPPORTED_PLATFORM: Self =
const_io_error!(ErrorKind::Unsupported, "operation not supported on this platform");
pub(crate) const WRITE_ALL_EOF: Self =
const_io_error!(ErrorKind::WriteZero, "failed to write whole buffer");
pub(crate) const ZERO_TIMEOUT: Self =
const_io_error!(ErrorKind::InvalidInput, "cannot set a 0 duration timeout");
}
#[stable(feature = "rust1", since = "1.0.0")]
impl From<alloc::ffi::NulError> for Error {
/// Converts a [`alloc::ffi::NulError`] into a [`Error`].

28
library/std/src/io/impls.rs
View file

@ -5,9 +5,7 @@
use crate::cmp;
use crate::collections::VecDeque;
use crate::fmt;
use crate::io::{
self, BorrowedCursor, BufRead, ErrorKind, IoSlice, IoSliceMut, Read, Seek, SeekFrom, Write,
};
use crate::io::{self, BorrowedCursor, BufRead, IoSlice, IoSliceMut, Read, Seek, SeekFrom, Write};
use crate::mem;
use crate::str;
@ -289,10 +287,7 @@ fn is_read_vectored(&self) -> bool {
#[inline]
fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
if buf.len() > self.len() {
return Err(io::const_io_error!(
ErrorKind::UnexpectedEof,
"failed to fill whole buffer"
));
return Err(io::Error::READ_EXACT_EOF);
}
let (a, b) = self.split_at(buf.len());
@ -312,10 +307,7 @@ fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
#[inline]
fn read_buf_exact(&mut self, mut cursor: BorrowedCursor<'_>) -> io::Result<()> {
if cursor.capacity() > self.len() {
return Err(io::const_io_error!(
ErrorKind::UnexpectedEof,
"failed to fill whole buffer"
));
return Err(io::Error::READ_EXACT_EOF);
}
let (a, b) = self.split_at(cursor.capacity());
@ -336,9 +328,7 @@ fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
#[inline]
fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> {
let content = str::from_utf8(self).map_err(|_| {
io::const_io_error!(ErrorKind::InvalidData, "stream did not contain valid UTF-8")
})?;
let content = str::from_utf8(self).map_err(|_| io::Error::INVALID_UTF8)?;
buf.push_str(content);
let len = self.len();
*self = &self[len..];
@ -399,11 +389,7 @@ fn is_write_vectored(&self) -> bool {
#[inline]
fn write_all(&mut self, data: &[u8]) -> io::Result<()> {
if self.write(data)? == data.len() {
Ok(())
} else {
Err(io::const_io_error!(ErrorKind::WriteZero, "failed to write whole buffer"))
}
if self.write(data)? == data.len() { Ok(()) } else { Err(io::Error::WRITE_ALL_EOF) }
}
#[inline]
@ -491,9 +477,7 @@ fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> {
// middle of an UTF-8 character.
let len = self.len();
let content = self.make_contiguous();
let string = str::from_utf8(content).map_err(|_| {
io::const_io_error!(ErrorKind::InvalidData, "stream did not contain valid UTF-8")
})?;
let string = str::from_utf8(content).map_err(|_| io::Error::INVALID_UTF8)?;
buf.push_str(string);
self.clear();
Ok(len)

28
library/std/src/io/mod.rs
View file

@ -385,12 +385,7 @@ pub(crate) unsafe fn append_to_string<F>(buf: &mut String, f: F) -> Result<usize
let mut g = Guard { len: buf.len(), buf: buf.as_mut_vec() };
let ret = f(g.buf);
if str::from_utf8(&g.buf[g.len..]).is_err() {
ret.and_then(|_| {
Err(error::const_io_error!(
ErrorKind::InvalidData,
"stream did not contain valid UTF-8"
))
})
ret.and_then(|_| Err(Error::INVALID_UTF8))
} else {
g.len = g.buf.len();
ret
@ -566,11 +561,7 @@ pub(crate) fn default_read_exact<R: Read + ?Sized>(this: &mut R, mut buf: &mut [
Err(e) => return Err(e),
}
}
if !buf.is_empty() {
Err(error::const_io_error!(ErrorKind::UnexpectedEof, "failed to fill whole buffer"))
} else {
Ok(())
}
if !buf.is_empty() { Err(Error::READ_EXACT_EOF) } else { Ok(()) }
}
pub(crate) fn default_read_buf<F>(read: F, mut cursor: BorrowedCursor<'_>) -> Result<()>
@ -595,10 +586,7 @@ pub(crate) fn default_read_buf_exact<R: Read + ?Sized>(
}
if cursor.written() == prev_written {
return Err(error::const_io_error!(
ErrorKind::UnexpectedEof,
"failed to fill whole buffer"
));
return Err(Error::READ_EXACT_EOF);
}
}
@ -1709,10 +1697,7 @@ fn write_all(&mut self, mut buf: &[u8]) -> Result<()> {
while !buf.is_empty() {
match self.write(buf) {
Ok(0) => {
return Err(error::const_io_error!(
ErrorKind::WriteZero,
"failed to write whole buffer",
));
return Err(Error::WRITE_ALL_EOF);
}
Ok(n) => buf = &buf[n..],
Err(ref e) if e.is_interrupted() => {}
@ -1777,10 +1762,7 @@ fn write_all_vectored(&mut self, mut bufs: &mut [IoSlice<'_>]) -> Result<()> {
while !bufs.is_empty() {
match self.write_vectored(bufs) {
Ok(0) => {
return Err(error::const_io_error!(
ErrorKind::WriteZero,
"failed to write whole buffer",
));
return Err(Error::WRITE_ALL_EOF);
}
Ok(n) => IoSlice::advance_slices(&mut bufs, n),
Err(ref e) if e.is_interrupted() => {}

5
library/std/src/os/fd/owned.rs
View file

@ -117,10 +117,7 @@ pub fn try_clone_to_owned(&self) -> crate::io::Result<OwnedFd> {
#[cfg(any(target_arch = "wasm32", target_os = "hermit"))]
#[stable(feature = "io_safety", since = "1.63.0")]
pub fn try_clone_to_owned(&self) -> crate::io::Result<OwnedFd> {
Err(crate::io::const_io_error!(
crate::io::ErrorKind::Unsupported,
"operation not supported on this platform",
))
Err(crate::io::Error::UNSUPPORTED_PLATFORM)
}
}

11
library/std/src/os/unix/fs.rs
View file

@ -127,11 +127,7 @@ fn read_exact_at(&self, mut buf: &mut [u8], mut offset: u64) -> io::Result<()> {
Err(e) => return Err(e),
}
}
if !buf.is_empty() {
Err(io::const_io_error!(io::ErrorKind::UnexpectedEof, "failed to fill whole buffer",))
} else {
Ok(())
}
if !buf.is_empty() { Err(io::Error::READ_EXACT_EOF) } else { Ok(()) }
}
/// Writes a number of bytes starting from a given offset.
@ -249,10 +245,7 @@ fn write_all_at(&self, mut buf: &[u8], mut offset: u64) -> io::Result<()> {
while !buf.is_empty() {
match self.write_at(buf, offset) {
Ok(0) => {
return Err(io::const_io_error!(
io::ErrorKind::WriteZero,
"failed to write whole buffer",
));
return Err(io::Error::WRITE_ALL_EOF);
}
Ok(n) => {
buf = &buf[n..];

11
library/std/src/os/wasi/fs.rs
View file

@ -86,11 +86,7 @@ fn read_exact_at(&self, mut buf: &mut [u8], mut offset: u64) -> io::Result<()> {
Err(e) => return Err(e),
}
}
if !buf.is_empty() {
Err(io::const_io_error!(io::ErrorKind::UnexpectedEof, "failed to fill whole buffer"))
} else {
Ok(())
}
if !buf.is_empty() { Err(io::Error::READ_EXACT_EOF) } else { Ok(()) }
}
/// Writes a number of bytes starting from a given offset.
@ -153,10 +149,7 @@ fn write_all_at(&self, mut buf: &[u8], mut offset: u64) -> io::Result<()> {
while !buf.is_empty() {
match self.write_at(buf, offset) {
Ok(0) => {
return Err(io::const_io_error!(
io::ErrorKind::WriteZero,
"failed to write whole buffer",
));
return Err(io::Error::WRITE_ALL_EOF);
}
Ok(n) => {
buf = &buf[n..];

10
library/std/src/sys/pal/hermit/net.rs
View file

@ -80,10 +80,7 @@ pub fn connect_timeout(&self, addr: &SocketAddr, timeout: Duration) -> io::Resul
let mut pollfd = netc::pollfd { fd: self.as_raw_fd(), events: netc::POLLOUT, revents: 0 };
if timeout.as_secs() == 0 && timeout.subsec_nanos() == 0 {
return Err(io::const_io_error!(
io::ErrorKind::InvalidInput,
"cannot set a 0 duration timeout",
));
return Err(io::Error::ZERO_TIMEOUT);
}
let start = Instant::now();
@ -245,10 +242,7 @@ pub fn set_timeout(&self, dur: Option<Duration>, kind: i32) -> io::Result<()> {
let timeout = match dur {
Some(dur) => {
if dur.as_secs() == 0 && dur.subsec_nanos() == 0 {
return Err(io::const_io_error!(
io::ErrorKind::InvalidInput,
"cannot set a 0 duration timeout",
));
return Err(io::Error::ZERO_TIMEOUT);
}
let secs = if dur.as_secs() > netc::time_t::MAX as u64 {

15
library/std/src/sys/pal/sgx/net.rs
View file

@ -97,10 +97,7 @@ pub fn connect(addr: io::Result<&SocketAddr>) -> io::Result<TcpStream> {
pub fn connect_timeout(addr: &SocketAddr, dur: Duration) -> io::Result<TcpStream> {
if dur == Duration::default() {
return Err(io::const_io_error!(
io::ErrorKind::InvalidInput,
"cannot set a 0 duration timeout",
));
return Err(io::Error::ZERO_TIMEOUT);
}
Self::connect(Ok(addr)) // FIXME: ignoring timeout
}
@ -108,10 +105,7 @@ pub fn connect_timeout(addr: &SocketAddr, dur: Duration) -> io::Result<TcpStream
pub fn set_read_timeout(&self, dur: Option<Duration>) -> io::Result<()> {
match dur {
Some(dur) if dur == Duration::default() => {
return Err(io::const_io_error!(
io::ErrorKind::InvalidInput,
"cannot set a 0 duration timeout",
));
return Err(io::Error::ZERO_TIMEOUT);
}
_ => sgx_ineffective(()),
}
@ -120,10 +114,7 @@ pub fn set_read_timeout(&self, dur: Option<Duration>) -> io::Result<()> {
pub fn set_write_timeout(&self, dur: Option<Duration>) -> io::Result<()> {
match dur {
Some(dur) if dur == Duration::default() => {
return Err(io::const_io_error!(
io::ErrorKind::InvalidInput,
"cannot set a 0 duration timeout",
));
return Err(io::Error::ZERO_TIMEOUT);
}
_ => sgx_ineffective(()),
}

5
library/std/src/sys/pal/solid/mod.rs
View file

@ -50,10 +50,7 @@ pub fn unsupported<T>() -> crate::io::Result<T> {
}
pub fn unsupported_err() -> crate::io::Error {
crate::io::const_io_error!(
crate::io::ErrorKind::Unsupported,
"operation not supported on this platform",
)
crate::io::Error::UNSUPPORTED_PLATFORM
}
#[inline]

10
library/std/src/sys/pal/solid/net.rs
View file

@ -154,10 +154,7 @@ pub fn connect_timeout(&self, addr: &SocketAddr, timeout: Duration) -> io::Resul
}
if timeout.as_secs() == 0 && timeout.subsec_nanos() == 0 {
return Err(io::const_io_error!(
io::ErrorKind::InvalidInput,
"cannot set a 0 duration timeout",
));
return Err(io::Error::ZERO_TIMEOUT);
}
let mut timeout =
@ -306,10 +303,7 @@ pub fn set_timeout(&self, dur: Option<Duration>, kind: c_int) -> io::Result<()>
let timeout = match dur {
Some(dur) => {
if dur.as_secs() == 0 && dur.subsec_nanos() == 0 {
return Err(io::const_io_error!(
io::ErrorKind::InvalidInput,
"cannot set a 0 duration timeout",
));
return Err(io::Error::ZERO_TIMEOUT);
}
let secs = if dur.as_secs() > netc::c_long::MAX as u64 {

5
library/std/src/sys/pal/teeos/thread.rs
View file

@ -141,10 +141,7 @@ fn drop(&mut self) {
// Note: Both `sched_getaffinity` and `sysconf` are available but not functional on
// teeos, so this function always returns an Error!
pub fn available_parallelism() -> io::Result<NonZero<usize>> {
Err(io::Error::new(
io::ErrorKind::NotFound,
"The number of hardware threads is not known for the target platform",
))
Err(io::Error::UNKNOWN_THREAD_COUNT)
}
fn min_stack_size(_: *const libc::pthread_attr_t) -> usize {

2
library/std/src/sys/pal/unix/mod.rs
View file

@ -433,6 +433,6 @@ pub fn unsupported<T>() -> io::Result<T> {
}
pub fn unsupported_err() -> io::Error {
io::const_io_error!(io::ErrorKind::Unsupported, "operation not supported on this platform",)
io::Error::UNSUPPORTED_PLATFORM
}
}

10
library/std/src/sys/pal/unix/net.rs
View file

@ -175,10 +175,7 @@ pub fn connect_timeout(&self, addr: &SocketAddr, timeout: Duration) -> io::Resul
let mut pollfd = libc::pollfd { fd: self.as_raw_fd(), events: libc::POLLOUT, revents: 0 };
if timeout.as_secs() == 0 && timeout.subsec_nanos() == 0 {
return Err(io::const_io_error!(
io::ErrorKind::InvalidInput,
"cannot set a 0 duration timeout",
));
return Err(io::Error::ZERO_TIMEOUT);
}
let start = Instant::now();
@ -360,10 +357,7 @@ pub fn set_timeout(&self, dur: Option<Duration>, kind: libc::c_int) -> io::Resul
let timeout = match dur {
Some(dur) => {
if dur.as_secs() == 0 && dur.subsec_nanos() == 0 {
return Err(io::const_io_error!(
io::ErrorKind::InvalidInput,
"cannot set a 0 duration timeout",
));
return Err(io::Error::ZERO_TIMEOUT);
}
let secs = if dur.as_secs() > libc::time_t::MAX as u64 {

10
library/std/src/sys/pal/unix/thread.rs
View file

@ -356,7 +356,7 @@ pub fn available_parallelism() -> io::Result<NonZero<usize>> {
}
match unsafe { libc::sysconf(libc::_SC_NPROCESSORS_ONLN) } {
-1 => Err(io::Error::last_os_error()),
0 => Err(io::const_io_error!(io::ErrorKind::NotFound, "The number of hardware threads is not known for the target platform")),
0 => Err(io::Error::UNKNOWN_THREAD_COUNT),
cpus => {
let count = cpus as usize;
// Cover the unusual situation where we were able to get the quota but not the affinity mask
@ -439,7 +439,7 @@ pub fn available_parallelism() -> io::Result<NonZero<usize>> {
if res == -1 {
return Err(io::Error::last_os_error());
} else if cpus == 0 {
return Err(io::const_io_error!(io::ErrorKind::NotFound, "The number of hardware threads is not known for the target platform"));
return Err(io::Error::UNKNOWN_THREAD_COUNT);
}
}
@ -452,13 +452,13 @@ pub fn available_parallelism() -> io::Result<NonZero<usize>> {
} else {
let cpus = (*_syspage_ptr).num_cpu;
NonZero::new(cpus as usize)
.ok_or(io::const_io_error!(io::ErrorKind::NotFound, "The number of hardware threads is not known for the target platform"))
.ok_or(io::Error::UNKNOWN_THREAD_COUNT)
}
}
} else if #[cfg(any(target_os = "solaris", target_os = "illumos"))] {
let mut cpus = 0u32;
if unsafe { libc::pset_info(libc::PS_MYID, core::ptr::null_mut(), &mut cpus, core::ptr::null_mut()) } != 0 {
return Err(io::const_io_error!(io::ErrorKind::NotFound, "The number of hardware threads is not known for the target platform"));
return Err(io::Error::UNKNOWN_THREAD_COUNT);
}
Ok(unsafe { NonZero::new_unchecked(cpus as usize) })
} else if #[cfg(target_os = "haiku")] {
@ -469,7 +469,7 @@ pub fn available_parallelism() -> io::Result<NonZero<usize>> {
let res = libc::get_system_info(&mut sinfo);
if res != libc::B_OK {
return Err(io::const_io_error!(io::ErrorKind::NotFound, "The number of hardware threads is not known for the target platform"));
return Err(io::Error::UNKNOWN_THREAD_COUNT);
}
Ok(NonZero::new_unchecked(sinfo.cpu_count as usize))

5
library/std/src/sys/pal/unsupported/common.rs
View file

@ -13,10 +13,7 @@ pub fn unsupported<T>() -> std_io::Result<T> {
}
pub fn unsupported_err() -> std_io::Error {
std_io::const_io_error!(
std_io::ErrorKind::Unsupported,
"operation not supported on this platform",
)
std_io::Error::UNSUPPORTED_PLATFORM
}
pub fn is_interrupted(_code: i32) -> bool {

10
library/std/src/sys/pal/windows/net.rs
View file

@ -154,10 +154,7 @@ pub fn connect_timeout(&self, addr: &SocketAddr, timeout: Duration) -> io::Resul
match result {
Err(ref error) if error.kind() == io::ErrorKind::WouldBlock => {
if timeout.as_secs() == 0 && timeout.subsec_nanos() == 0 {
return Err(io::const_io_error!(
io::ErrorKind::InvalidInput,
"cannot set a 0 duration timeout",
));
return Err(io::Error::ZERO_TIMEOUT);
}
let mut timeout = c::timeval {
@ -364,10 +361,7 @@ pub fn set_timeout(&self, dur: Option<Duration>, kind: c_int) -> io::Result<()>
Some(dur) => {
let timeout = sys::dur2timeout(dur);
if timeout == 0 {
return Err(io::const_io_error!(
io::ErrorKind::InvalidInput,
"cannot set a 0 duration timeout",
));
return Err(io::Error::ZERO_TIMEOUT);
}
timeout
}

5
library/std/src/sys/pal/windows/thread.rs
View file

@ -116,10 +116,7 @@ pub fn available_parallelism() -> io::Result<NonZero<usize>> {
sysinfo.dwNumberOfProcessors as usize
};
match res {
0 => Err(io::const_io_error!(
io::ErrorKind::NotFound,
"The number of hardware threads is not known for the target platform",
)),
0 => Err(io::Error::UNKNOWN_THREAD_COUNT),
cpus => Ok(unsafe { NonZero::new_unchecked(cpus) }),
}
}

10
library/std/src/sys/pal/xous/net/tcpstream.rs
View file

@ -140,10 +140,7 @@ pub fn connect_timeout(addr: &SocketAddr, duration: Duration) -> io::Result<TcpS
pub fn set_read_timeout(&self, timeout: Option<Duration>) -> io::Result<()> {
if let Some(to) = timeout {
if to.is_zero() {
return Err(io::const_io_error!(
io::ErrorKind::InvalidInput,
&"Zero is an invalid timeout",
));
return Err(io::Error::ZERO_TIMEOUT);
}
}
self.read_timeout.store(
@ -156,10 +153,7 @@ pub fn set_read_timeout(&self, timeout: Option<Duration>) -> io::Result<()> {
pub fn set_write_timeout(&self, timeout: Option<Duration>) -> io::Result<()> {
if let Some(to) = timeout {
if to.is_zero() {
return Err(io::const_io_error!(
io::ErrorKind::InvalidInput,
&"Zero is an invalid timeout",
));
return Err(io::Error::ZERO_TIMEOUT);
}
}
self.write_timeout.store(

10
library/std/src/sys/pal/xous/net/udp.rs
View file

@ -331,10 +331,7 @@ pub fn duplicate(&self) -> io::Result<UdpSocket> {
pub fn set_read_timeout(&self, timeout: Option<Duration>) -> io::Result<()> {
if let Some(d) = timeout {
if d.is_zero() {
return Err(io::const_io_error!(
io::ErrorKind::InvalidInput,
&"Zero duration is invalid"
));
return Err(io::Error::ZERO_TIMEOUT);
}
}
self.read_timeout
@ -345,10 +342,7 @@ pub fn set_read_timeout(&self, timeout: Option<Duration>) -> io::Result<()> {
pub fn set_write_timeout(&self, timeout: Option<Duration>) -> io::Result<()> {
if let Some(d) = timeout {
if d.is_zero() {
return Err(io::const_io_error!(
io::ErrorKind::InvalidInput,
&"Zero duration is invalid"
));
return Err(io::Error::ZERO_TIMEOUT);
}
}
self.write_timeout

5
library/std/src/sys/pal/zkvm/mod.rs
View file

@ -54,10 +54,7 @@ pub fn unsupported<T>() -> std_io::Result<T> {
}
pub fn unsupported_err() -> std_io::Error {
std_io::const_io_error!(
std_io::ErrorKind::Unsupported,
"operation not supported on this platform",
)
std_io::Error::UNSUPPORTED_PLATFORM
}
pub fn is_interrupted(_code: i32) -> bool {