#[cfg(test)] mod tests; #[cfg(target_pointer_width = "64")] mod repr_bitpacked; #[cfg(target_pointer_width = "64")] use repr_bitpacked::Repr; #[cfg(not(target_pointer_width = "64"))] mod repr_unpacked; #[cfg(not(target_pointer_width = "64"))] use repr_unpacked::Repr; use crate::convert::From; use crate::error; use crate::fmt; use crate::result; use crate::sys; /// A specialized [`Result`] type for I/O operations. /// /// This type is broadly used across [`std::io`] for any operation which may /// produce an error. /// /// This typedef is generally used to avoid writing out [`io::Error`] directly and /// is otherwise a direct mapping to [`Result`]. /// /// While usual Rust style is to import types directly, aliases of [`Result`] /// often are not, to make it easier to distinguish between them. [`Result`] is /// generally assumed to be [`std::result::Result`][`Result`], and so users of this alias /// will generally use `io::Result` instead of shadowing the [prelude]'s import /// of [`std::result::Result`][`Result`]. /// /// [`std::io`]: crate::io /// [`io::Error`]: Error /// [`Result`]: crate::result::Result /// [prelude]: crate::prelude /// /// # Examples /// /// A convenience function that bubbles an `io::Result` to its caller: /// /// ``` /// use std::io; /// /// fn get_string() -> io::Result { /// let mut buffer = String::new(); /// /// io::stdin().read_line(&mut buffer)?; /// /// Ok(buffer) /// } /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub type Result = result::Result; /// The error type for I/O operations of the [`Read`], [`Write`], [`Seek`], and /// associated traits. /// /// Errors mostly originate from the underlying OS, but custom instances of /// `Error` can be created with crafted error messages and a particular value of /// [`ErrorKind`]. /// /// [`Read`]: crate::io::Read /// [`Write`]: crate::io::Write /// [`Seek`]: crate::io::Seek #[stable(feature = "rust1", since = "1.0.0")] pub struct Error { repr: Repr, } #[stable(feature = "rust1", since = "1.0.0")] impl fmt::Debug for Error { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fmt::Debug::fmt(&self.repr, f) } } // Only derive debug in tests, to make sure it // doesn't accidentally get printed. #[cfg_attr(test, derive(Debug))] enum ErrorData { Os(i32), Simple(ErrorKind), SimpleMessage(&'static SimpleMessage), Custom(C), } // `#[repr(align(4))]` is probably redundant, it should have that value or // higher already. We include it just because repr_bitpacked.rs's encoding // requires an alignment >= 4 (note that `#[repr(align)]` will not reduce the // alignment required by the struct, only increase it). // // If we add more variants to ErrorData, this can be increased to 8, but it // should probably be behind `#[cfg_attr(target_pointer_width = "64", ...)]` or // whatever cfg we're using to enable the `repr_bitpacked` code, since only the // that version needs the alignment, and 8 is higher than the alignment we'll // have on 32 bit platforms. // // (For the sake of being explicit: the alignment requirement here only matters // if `error/repr_bitpacked.rs` is in use — for the unpacked repr it doesn't // matter at all) #[repr(align(4))] #[derive(Debug)] pub(crate) struct SimpleMessage { kind: ErrorKind, message: &'static str, } impl SimpleMessage { pub(crate) const fn new(kind: ErrorKind, message: &'static str) -> Self { Self { kind, message } } } /// Create and return an `io::Error` for a given `ErrorKind` and constant /// message. This doesn't allocate. pub(crate) macro const_io_error($kind:expr, $message:expr $(,)?) { $crate::io::error::Error::from_static_message({ const MESSAGE_DATA: $crate::io::error::SimpleMessage = $crate::io::error::SimpleMessage::new($kind, $message); &MESSAGE_DATA }) } // As with `SimpleMessage`: `#[repr(align(4))]` here is just because // repr_bitpacked's encoding requires it. In practice it almost certainly be // already be this high or higher. #[derive(Debug)] #[repr(align(4))] struct Custom { kind: ErrorKind, error: Box, } /// A list specifying general categories of I/O error. /// /// This list is intended to grow over time and it is not recommended to /// exhaustively match against it. /// /// It is used with the [`io::Error`] type. /// /// [`io::Error`]: Error /// /// # Handling errors and matching on `ErrorKind` /// /// In application code, use `match` for the `ErrorKind` values you are /// expecting; use `_` to match "all other errors". /// /// In comprehensive and thorough tests that want to verify that a test doesn't /// return any known incorrect error kind, you may want to cut-and-paste the /// current full list of errors from here into your test code, and then match /// `_` as the correct case. This seems counterintuitive, but it will make your /// tests more robust. In particular, if you want to verify that your code does /// produce an unrecognized error kind, the robust solution is to check for all /// the recognized error kinds and fail in those cases. #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] #[stable(feature = "rust1", since = "1.0.0")] #[allow(deprecated)] #[non_exhaustive] pub enum ErrorKind { /// An entity was not found, often a file. #[stable(feature = "rust1", since = "1.0.0")] NotFound, /// The operation lacked the necessary privileges to complete. #[stable(feature = "rust1", since = "1.0.0")] PermissionDenied, /// The connection was refused by the remote server. #[stable(feature = "rust1", since = "1.0.0")] ConnectionRefused, /// The connection was reset by the remote server. #[stable(feature = "rust1", since = "1.0.0")] ConnectionReset, /// The remote host is not reachable. #[unstable(feature = "io_error_more", issue = "86442")] HostUnreachable, /// The network containing the remote host is not reachable. #[unstable(feature = "io_error_more", issue = "86442")] NetworkUnreachable, /// The connection was aborted (terminated) by the remote server. #[stable(feature = "rust1", since = "1.0.0")] ConnectionAborted, /// The network operation failed because it was not connected yet. #[stable(feature = "rust1", since = "1.0.0")] NotConnected, /// A socket address could not be bound because the address is already in /// use elsewhere. #[stable(feature = "rust1", since = "1.0.0")] AddrInUse, /// A nonexistent interface was requested or the requested address was not /// local. #[stable(feature = "rust1", since = "1.0.0")] AddrNotAvailable, /// The system's networking is down. #[unstable(feature = "io_error_more", issue = "86442")] NetworkDown, /// The operation failed because a pipe was closed. #[stable(feature = "rust1", since = "1.0.0")] BrokenPipe, /// An entity already exists, often a file. #[stable(feature = "rust1", since = "1.0.0")] AlreadyExists, /// The operation needs to block to complete, but the blocking operation was /// requested to not occur. #[stable(feature = "rust1", since = "1.0.0")] WouldBlock, /// A filesystem object is, unexpectedly, not a directory. /// /// For example, a filesystem path was specified where one of the intermediate directory /// components was, in fact, a plain file. #[unstable(feature = "io_error_more", issue = "86442")] NotADirectory, /// The filesystem object is, unexpectedly, a directory. /// /// A directory was specified when a non-directory was expected. #[unstable(feature = "io_error_more", issue = "86442")] IsADirectory, /// A non-empty directory was specified where an empty directory was expected. #[unstable(feature = "io_error_more", issue = "86442")] DirectoryNotEmpty, /// The filesystem or storage medium is read-only, but a write operation was attempted. #[unstable(feature = "io_error_more", issue = "86442")] ReadOnlyFilesystem, /// Loop in the filesystem or IO subsystem; often, too many levels of symbolic links. /// /// There was a loop (or excessively long chain) resolving a filesystem object /// or file IO object. /// /// On Unix this is usually the result of a symbolic link loop; or, of exceeding the /// system-specific limit on the depth of symlink traversal. #[unstable(feature = "io_error_more", issue = "86442")] FilesystemLoop, /// Stale network file handle. /// /// With some network filesystems, notably NFS, an open file (or directory) can be invalidated /// by problems with the network or server. #[unstable(feature = "io_error_more", issue = "86442")] StaleNetworkFileHandle, /// A parameter was incorrect. #[stable(feature = "rust1", since = "1.0.0")] InvalidInput, /// Data not valid for the operation were encountered. /// /// Unlike [`InvalidInput`], this typically means that the operation /// parameters were valid, however the error was caused by malformed /// input data. /// /// For example, a function that reads a file into a string will error with /// `InvalidData` if the file's contents are not valid UTF-8. /// /// [`InvalidInput`]: ErrorKind::InvalidInput #[stable(feature = "io_invalid_data", since = "1.2.0")] InvalidData, /// The I/O operation's timeout expired, causing it to be canceled. #[stable(feature = "rust1", since = "1.0.0")] TimedOut, /// An error returned when an operation could not be completed because a /// call to [`write`] returned [`Ok(0)`]. /// /// This typically means that an operation could only succeed if it wrote a /// particular number of bytes but only a smaller number of bytes could be /// written. /// /// [`write`]: crate::io::Write::write /// [`Ok(0)`]: Ok #[stable(feature = "rust1", since = "1.0.0")] WriteZero, /// The underlying storage (typically, a filesystem) is full. /// /// This does not include out of quota errors. #[unstable(feature = "io_error_more", issue = "86442")] StorageFull, /// Seek on unseekable file. /// /// Seeking was attempted on an open file handle which is not suitable for seeking - for /// example, on Unix, a named pipe opened with `File::open`. #[unstable(feature = "io_error_more", issue = "86442")] NotSeekable, /// Filesystem quota was exceeded. #[unstable(feature = "io_error_more", issue = "86442")] FilesystemQuotaExceeded, /// File larger than allowed or supported. /// /// This might arise from a hard limit of the underlying filesystem or file access API, or from /// an administratively imposed resource limitation. Simple disk full, and out of quota, have /// their own errors. #[unstable(feature = "io_error_more", issue = "86442")] FileTooLarge, /// Resource is busy. #[unstable(feature = "io_error_more", issue = "86442")] ResourceBusy, /// Executable file is busy. /// /// An attempt was made to write to a file which is also in use as a running program. (Not all /// operating systems detect this situation.) #[unstable(feature = "io_error_more", issue = "86442")] ExecutableFileBusy, /// Deadlock (avoided). /// /// A file locking operation would result in deadlock. This situation is typically detected, if /// at all, on a best-effort basis. #[unstable(feature = "io_error_more", issue = "86442")] Deadlock, /// Cross-device or cross-filesystem (hard) link or rename. #[unstable(feature = "io_error_more", issue = "86442")] CrossesDevices, /// Too many (hard) links to the same filesystem object. /// /// The filesystem does not support making so many hardlinks to the same file. #[unstable(feature = "io_error_more", issue = "86442")] TooManyLinks, /// A filename was invalid. /// /// This error can also cause if it exceeded the filename length limit. #[unstable(feature = "io_error_more", issue = "86442")] InvalidFilename, /// Program argument list too long. /// /// When trying to run an external program, a system or process limit on the size of the /// arguments would have been exceeded. #[unstable(feature = "io_error_more", issue = "86442")] ArgumentListTooLong, /// This operation was interrupted. /// /// Interrupted operations can typically be retried. #[stable(feature = "rust1", since = "1.0.0")] Interrupted, /// This operation is unsupported on this platform. /// /// This means that the operation can never succeed. #[stable(feature = "unsupported_error", since = "1.53.0")] Unsupported, // ErrorKinds which are primarily categorisations for OS error // codes should be added above. // /// An error returned when an operation could not be completed because an /// "end of file" was reached prematurely. /// /// This typically means that an operation could only succeed if it read a /// particular number of bytes but only a smaller number of bytes could be /// read. #[stable(feature = "read_exact", since = "1.6.0")] UnexpectedEof, /// An operation could not be completed, because it failed /// to allocate enough memory. #[stable(feature = "out_of_memory_error", since = "1.54.0")] OutOfMemory, // "Unusual" error kinds which do not correspond simply to (sets // of) OS error codes, should be added just above this comment. // `Other` and `Uncategorised` should remain at the end: // /// A custom error that does not fall under any other I/O error kind. /// /// This can be used to construct your own [`Error`]s that do not match any /// [`ErrorKind`]. /// /// This [`ErrorKind`] is not used by the standard library. /// /// Errors from the standard library that do not fall under any of the I/O /// error kinds cannot be `match`ed on, and will only match a wildcard (`_`) pattern. /// New [`ErrorKind`]s might be added in the future for some of those. #[stable(feature = "rust1", since = "1.0.0")] Other, /// Any I/O error from the standard library that's not part of this list. /// /// Errors that are `Uncategorized` now may move to a different or a new /// [`ErrorKind`] variant in the future. It is not recommended to match /// an error against `Uncategorized`; use a wildcard match (`_`) instead. #[unstable(feature = "io_error_uncategorized", issue = "none")] #[doc(hidden)] Uncategorized, } impl ErrorKind { pub(crate) fn as_str(&self) -> &'static str { use ErrorKind::*; // Strictly alphabetical, please. (Sadly rustfmt cannot do this yet.) match *self { AddrInUse => "address in use", AddrNotAvailable => "address not available", AlreadyExists => "entity already exists", ArgumentListTooLong => "argument list too long", BrokenPipe => "broken pipe", ConnectionAborted => "connection aborted", ConnectionRefused => "connection refused", ConnectionReset => "connection reset", CrossesDevices => "cross-device link or rename", Deadlock => "deadlock", DirectoryNotEmpty => "directory not empty", ExecutableFileBusy => "executable file busy", FileTooLarge => "file too large", FilesystemLoop => "filesystem loop or indirection limit (e.g. symlink loop)", FilesystemQuotaExceeded => "filesystem quota exceeded", HostUnreachable => "host unreachable", Interrupted => "operation interrupted", InvalidData => "invalid data", InvalidFilename => "invalid filename", InvalidInput => "invalid input parameter", IsADirectory => "is a directory", NetworkDown => "network down", NetworkUnreachable => "network unreachable", NotADirectory => "not a directory", NotConnected => "not connected", NotFound => "entity not found", NotSeekable => "seek on unseekable file", Other => "other error", OutOfMemory => "out of memory", PermissionDenied => "permission denied", ReadOnlyFilesystem => "read-only filesystem or storage medium", ResourceBusy => "resource busy", StaleNetworkFileHandle => "stale network file handle", StorageFull => "no storage space", TimedOut => "timed out", TooManyLinks => "too many links", Uncategorized => "uncategorized error", UnexpectedEof => "unexpected end of file", Unsupported => "unsupported", WouldBlock => "operation would block", WriteZero => "write zero", } } } #[stable(feature = "io_errorkind_display", since = "1.60.0")] impl fmt::Display for ErrorKind { /// Shows a human-readable description of the `ErrorKind`. /// /// This is similar to `impl Display for Error`, but doesn't require first converting to Error. /// /// # Examples /// ``` /// use std::io::ErrorKind; /// assert_eq!("entity not found", ErrorKind::NotFound.to_string()); /// ``` fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { fmt.write_str(self.as_str()) } } /// Intended for use for errors not exposed to the user, where allocating onto /// the heap (for normal construction via Error::new) is too costly. #[stable(feature = "io_error_from_errorkind", since = "1.14.0")] impl From for Error { /// Converts an [`ErrorKind`] into an [`Error`]. /// /// This conversion creates a new error with a simple representation of error kind. /// /// # Examples /// /// ``` /// use std::io::{Error, ErrorKind}; /// /// let not_found = ErrorKind::NotFound; /// let error = Error::from(not_found); /// assert_eq!("entity not found", format!("{error}")); /// ``` #[inline] fn from(kind: ErrorKind) -> Error { Error { repr: Repr::new_simple(kind) } } } impl Error { /// Creates a new I/O error from a known kind of error as well as an /// arbitrary error payload. /// /// This function is used to generically create I/O errors which do not /// originate from the OS itself. The `error` argument is an arbitrary /// payload which will be contained in this [`Error`]. /// /// If no extra payload is required, use the `From` conversion from /// `ErrorKind`. /// /// # Examples /// /// ``` /// use std::io::{Error, ErrorKind}; /// /// // errors can be created from strings /// let custom_error = Error::new(ErrorKind::Other, "oh no!"); /// /// // errors can also be created from other errors /// let custom_error2 = Error::new(ErrorKind::Interrupted, custom_error); /// /// // creating an error without payload /// let eof_error = Error::from(ErrorKind::UnexpectedEof); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn new(kind: ErrorKind, error: E) -> Error where E: Into>, { Self::_new(kind, error.into()) } /// Creates a new I/O error from an arbitrary error payload. /// /// This function is used to generically create I/O errors which do not /// originate from the OS itself. It is a shortcut for [`Error::new`] /// with [`ErrorKind::Other`]. /// /// # Examples /// /// ``` /// #![feature(io_error_other)] /// /// use std::io::Error; /// /// // errors can be created from strings /// let custom_error = Error::other("oh no!"); /// /// // errors can also be created from other errors /// let custom_error2 = Error::other(custom_error); /// ``` #[unstable(feature = "io_error_other", issue = "91946")] pub fn other(error: E) -> Error where E: Into>, { Self::_new(ErrorKind::Other, error.into()) } fn _new(kind: ErrorKind, error: Box) -> Error { Error { repr: Repr::new_custom(Box::new(Custom { kind, error })) } } /// Creates a new I/O error from a known kind of error as well as a constant /// message. /// /// This function does not allocate. /// /// You should not use this directly, and instead use the `const_io_error!` /// macro: `io::const_io_error!(ErrorKind::Something, "some_message")`. /// /// This function should maybe change to `from_static_message(kind: ErrorKind)` in the future, when const generics allow that. #[inline] pub(crate) const fn from_static_message(msg: &'static SimpleMessage) -> Error { Self { repr: Repr::new_simple_message(msg) } } /// Returns an error representing the last OS error which occurred. /// /// This function reads the value of `errno` for the target platform (e.g. /// `GetLastError` on Windows) and will return a corresponding instance of /// [`Error`] for the error code. /// /// This should be called immediately after a call to a platform function, /// otherwise the state of the error value is indeterminate. In particular, /// other standard library functions may call platform functions that may /// (or may not) reset the error value even if they succeed. /// /// # Examples /// /// ``` /// use std::io::Error; /// /// let os_error = Error::last_os_error(); /// println!("last OS error: {os_error:?}"); /// ``` #[stable(feature = "rust1", since = "1.0.0")] #[must_use] #[inline] pub fn last_os_error() -> Error { Error::from_raw_os_error(sys::os::errno() as i32) } /// Creates a new instance of an [`Error`] from a particular OS error code. /// /// # Examples /// /// On Linux: /// /// ``` /// # if cfg!(target_os = "linux") { /// use std::io; /// /// let error = io::Error::from_raw_os_error(22); /// assert_eq!(error.kind(), io::ErrorKind::InvalidInput); /// # } /// ``` /// /// On Windows: /// /// ``` /// # if cfg!(windows) { /// use std::io; /// /// let error = io::Error::from_raw_os_error(10022); /// assert_eq!(error.kind(), io::ErrorKind::InvalidInput); /// # } /// ``` #[stable(feature = "rust1", since = "1.0.0")] #[must_use] #[inline] pub fn from_raw_os_error(code: i32) -> Error { Error { repr: Repr::new_os(code) } } /// Returns the OS error that this error represents (if any). /// /// If this [`Error`] was constructed via [`last_os_error`] or /// [`from_raw_os_error`], then this function will return [`Some`], otherwise /// it will return [`None`]. /// /// [`last_os_error`]: Error::last_os_error /// [`from_raw_os_error`]: Error::from_raw_os_error /// /// # Examples /// /// ``` /// use std::io::{Error, ErrorKind}; /// /// fn print_os_error(err: &Error) { /// if let Some(raw_os_err) = err.raw_os_error() { /// println!("raw OS error: {raw_os_err:?}"); /// } else { /// println!("Not an OS error"); /// } /// } /// /// fn main() { /// // Will print "raw OS error: ...". /// print_os_error(&Error::last_os_error()); /// // Will print "Not an OS error". /// print_os_error(&Error::new(ErrorKind::Other, "oh no!")); /// } /// ``` #[stable(feature = "rust1", since = "1.0.0")] #[must_use] #[inline] pub fn raw_os_error(&self) -> Option { match self.repr.data() { ErrorData::Os(i) => Some(i), ErrorData::Custom(..) => None, ErrorData::Simple(..) => None, ErrorData::SimpleMessage(..) => None, } } /// Returns a reference to the inner error wrapped by this error (if any). /// /// If this [`Error`] was constructed via [`new`] then this function will /// return [`Some`], otherwise it will return [`None`]. /// /// [`new`]: Error::new /// /// # Examples /// /// ``` /// use std::io::{Error, ErrorKind}; /// /// fn print_error(err: &Error) { /// if let Some(inner_err) = err.get_ref() { /// println!("Inner error: {inner_err:?}"); /// } else { /// println!("No inner error"); /// } /// } /// /// fn main() { /// // Will print "No inner error". /// print_error(&Error::last_os_error()); /// // Will print "Inner error: ...". /// print_error(&Error::new(ErrorKind::Other, "oh no!")); /// } /// ``` #[stable(feature = "io_error_inner", since = "1.3.0")] #[must_use] #[inline] pub fn get_ref(&self) -> Option<&(dyn error::Error + Send + Sync + 'static)> { match self.repr.data() { ErrorData::Os(..) => None, ErrorData::Simple(..) => None, ErrorData::SimpleMessage(..) => None, ErrorData::Custom(c) => Some(&*c.error), } } /// Returns a mutable reference to the inner error wrapped by this error /// (if any). /// /// If this [`Error`] was constructed via [`new`] then this function will /// return [`Some`], otherwise it will return [`None`]. /// /// [`new`]: Error::new /// /// # Examples /// /// ``` /// use std::io::{Error, ErrorKind}; /// use std::{error, fmt}; /// use std::fmt::Display; /// /// #[derive(Debug)] /// struct MyError { /// v: String, /// } /// /// impl MyError { /// fn new() -> MyError { /// MyError { /// v: "oh no!".to_string() /// } /// } /// /// fn change_message(&mut self, new_message: &str) { /// self.v = new_message.to_string(); /// } /// } /// /// impl error::Error for MyError {} /// /// impl Display for MyError { /// fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { /// write!(f, "MyError: {}", &self.v) /// } /// } /// /// fn change_error(mut err: Error) -> Error { /// if let Some(inner_err) = err.get_mut() { /// inner_err.downcast_mut::().unwrap().change_message("I've been changed!"); /// } /// err /// } /// /// fn print_error(err: &Error) { /// if let Some(inner_err) = err.get_ref() { /// println!("Inner error: {inner_err}"); /// } else { /// println!("No inner error"); /// } /// } /// /// fn main() { /// // Will print "No inner error". /// print_error(&change_error(Error::last_os_error())); /// // Will print "Inner error: ...". /// print_error(&change_error(Error::new(ErrorKind::Other, MyError::new()))); /// } /// ``` #[stable(feature = "io_error_inner", since = "1.3.0")] #[must_use] #[inline] pub fn get_mut(&mut self) -> Option<&mut (dyn error::Error + Send + Sync + 'static)> { match self.repr.data_mut() { ErrorData::Os(..) => None, ErrorData::Simple(..) => None, ErrorData::SimpleMessage(..) => None, ErrorData::Custom(c) => Some(&mut *c.error), } } /// Consumes the `Error`, returning its inner error (if any). /// /// If this [`Error`] was constructed via [`new`] then this function will /// return [`Some`], otherwise it will return [`None`]. /// /// [`new`]: Error::new /// /// # Examples /// /// ``` /// use std::io::{Error, ErrorKind}; /// /// fn print_error(err: Error) { /// if let Some(inner_err) = err.into_inner() { /// println!("Inner error: {inner_err}"); /// } else { /// println!("No inner error"); /// } /// } /// /// fn main() { /// // Will print "No inner error". /// print_error(Error::last_os_error()); /// // Will print "Inner error: ...". /// print_error(Error::new(ErrorKind::Other, "oh no!")); /// } /// ``` #[stable(feature = "io_error_inner", since = "1.3.0")] #[must_use = "`self` will be dropped if the result is not used"] #[inline] pub fn into_inner(self) -> Option> { match self.repr.into_data() { ErrorData::Os(..) => None, ErrorData::Simple(..) => None, ErrorData::SimpleMessage(..) => None, ErrorData::Custom(c) => Some(c.error), } } /// Attempt to downgrade the inner error to `E` if any. /// /// If this [`Error`] was constructed via [`new`] then this function will /// attempt to perform downgrade on it, otherwise it will return [`Err`]. /// /// If downgrade succeeds, it will return [`Ok`], otherwise it will also /// return [`Err`]. /// /// [`new`]: Error::new /// /// # Examples /// /// ``` /// #![feature(io_error_downcast)] /// /// use std::fmt; /// use std::io; /// use std::error::Error; /// /// #[derive(Debug)] /// enum E { /// Io(io::Error), /// SomeOtherVariant, /// } /// /// impl fmt::Display for E { /// // ... /// # fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { /// # todo!() /// # } /// } /// impl Error for E {} /// /// impl From for E { /// fn from(err: io::Error) -> E { /// err.downcast::() /// .map(|b| *b) /// .unwrap_or_else(E::Io) /// } /// } /// ``` #[unstable(feature = "io_error_downcast", issue = "99262")] pub fn downcast(self) -> result::Result, Self> where E: error::Error + Send + Sync + 'static, { match self.repr.into_data() { ErrorData::Custom(b) if b.error.is::() => { let res = (*b).error.downcast::(); // downcast is a really trivial and is marked as inline, so // it's likely be inlined here. // // And the compiler should be able to eliminate the branch // that produces `Err` here since b.error.is::() // returns true. Ok(res.unwrap()) } repr_data => Err(Self { repr: Repr::new(repr_data) }), } } /// Returns the corresponding [`ErrorKind`] for this error. /// /// # Examples /// /// ``` /// use std::io::{Error, ErrorKind}; /// /// fn print_error(err: Error) { /// println!("{:?}", err.kind()); /// } /// /// fn main() { /// // Will print "Uncategorized". /// print_error(Error::last_os_error()); /// // Will print "AddrInUse". /// print_error(Error::new(ErrorKind::AddrInUse, "oh no!")); /// } /// ``` #[stable(feature = "rust1", since = "1.0.0")] #[must_use] #[inline] pub fn kind(&self) -> ErrorKind { match self.repr.data() { ErrorData::Os(code) => sys::decode_error_kind(code), ErrorData::Custom(c) => c.kind, ErrorData::Simple(kind) => kind, ErrorData::SimpleMessage(m) => m.kind, } } } impl fmt::Debug for Repr { fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { match self.data() { ErrorData::Os(code) => fmt .debug_struct("Os") .field("code", &code) .field("kind", &sys::decode_error_kind(code)) .field("message", &sys::os::error_string(code)) .finish(), ErrorData::Custom(c) => fmt::Debug::fmt(&c, fmt), ErrorData::Simple(kind) => fmt.debug_tuple("Kind").field(&kind).finish(), ErrorData::SimpleMessage(msg) => fmt .debug_struct("Error") .field("kind", &msg.kind) .field("message", &msg.message) .finish(), } } } #[stable(feature = "rust1", since = "1.0.0")] impl fmt::Display for Error { fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { match self.repr.data() { ErrorData::Os(code) => { let detail = sys::os::error_string(code); write!(fmt, "{detail} (os error {code})") } ErrorData::Custom(ref c) => c.error.fmt(fmt), ErrorData::Simple(kind) => write!(fmt, "{}", kind.as_str()), ErrorData::SimpleMessage(msg) => msg.message.fmt(fmt), } } } #[stable(feature = "rust1", since = "1.0.0")] impl error::Error for Error { #[allow(deprecated, deprecated_in_future)] fn description(&self) -> &str { match self.repr.data() { ErrorData::Os(..) | ErrorData::Simple(..) => self.kind().as_str(), ErrorData::SimpleMessage(msg) => msg.message, ErrorData::Custom(c) => c.error.description(), } } #[allow(deprecated)] fn cause(&self) -> Option<&dyn error::Error> { match self.repr.data() { ErrorData::Os(..) => None, ErrorData::Simple(..) => None, ErrorData::SimpleMessage(..) => None, ErrorData::Custom(c) => c.error.cause(), } } fn source(&self) -> Option<&(dyn error::Error + 'static)> { match self.repr.data() { ErrorData::Os(..) => None, ErrorData::Simple(..) => None, ErrorData::SimpleMessage(..) => None, ErrorData::Custom(c) => c.error.source(), } } } fn _assert_error_is_sync_send() { fn _is_sync_send() {} _is_sync_send::(); }