4 #[cfg(target_pointer_width = "64")]
6 #[cfg(target_pointer_width = "64")]
7 use repr_bitpacked::Repr;
9 #[cfg(not(target_pointer_width = "64"))]
11 #[cfg(not(target_pointer_width = "64"))]
12 use repr_unpacked::Repr;
14 use crate::convert::From;
20 /// A specialized [`Result`] type for I/O operations.
22 /// This type is broadly used across [`std::io`] for any operation which may
25 /// This typedef is generally used to avoid writing out [`io::Error`] directly and
26 /// is otherwise a direct mapping to [`Result`].
28 /// While usual Rust style is to import types directly, aliases of [`Result`]
29 /// often are not, to make it easier to distinguish between them. [`Result`] is
30 /// generally assumed to be [`std::result::Result`][`Result`], and so users of this alias
31 /// will generally use `io::Result` instead of shadowing the [prelude]'s import
32 /// of [`std::result::Result`][`Result`].
34 /// [`std::io`]: crate::io
35 /// [`io::Error`]: Error
36 /// [`Result`]: crate::result::Result
37 /// [prelude]: crate::prelude
41 /// A convenience function that bubbles an `io::Result` to its caller:
46 /// fn get_string() -> io::Result<String> {
47 /// let mut buffer = String::new();
49 /// io::stdin().read_line(&mut buffer)?;
54 #[stable(feature = "rust1", since = "1.0.0")]
55 pub type Result<T> = result::Result<T, Error>;
57 /// The error type for I/O operations of the [`Read`], [`Write`], [`Seek`], and
58 /// associated traits.
60 /// Errors mostly originate from the underlying OS, but custom instances of
61 /// `Error` can be created with crafted error messages and a particular value of
64 /// [`Read`]: crate::io::Read
65 /// [`Write`]: crate::io::Write
66 /// [`Seek`]: crate::io::Seek
67 #[stable(feature = "rust1", since = "1.0.0")]
72 #[stable(feature = "rust1", since = "1.0.0")]
73 impl fmt::Debug for Error {
74 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
75 fmt::Debug::fmt(&self.repr, f)
79 #[stable(feature = "rust1", since = "1.0.0")]
80 impl From<alloc::ffi::NulError> for Error {
81 /// Converts a [`alloc::ffi::NulError`] into a [`Error`].
82 fn from(_: alloc::ffi::NulError) -> Error {
83 const_io_error!(ErrorKind::InvalidInput, "data provided contains a nul byte")
87 // Only derive debug in tests, to make sure it
88 // doesn't accidentally get printed.
89 #[cfg_attr(test, derive(Debug))]
93 SimpleMessage(&'static SimpleMessage),
97 // `#[repr(align(4))]` is probably redundant, it should have that value or
98 // higher already. We include it just because repr_bitpacked.rs's encoding
99 // requires an alignment >= 4 (note that `#[repr(align)]` will not reduce the
100 // alignment required by the struct, only increase it).
102 // If we add more variants to ErrorData, this can be increased to 8, but it
103 // should probably be behind `#[cfg_attr(target_pointer_width = "64", ...)]` or
104 // whatever cfg we're using to enable the `repr_bitpacked` code, since only the
105 // that version needs the alignment, and 8 is higher than the alignment we'll
106 // have on 32 bit platforms.
108 // (For the sake of being explicit: the alignment requirement here only matters
109 // if `error/repr_bitpacked.rs` is in use — for the unpacked repr it doesn't
113 pub(crate) struct SimpleMessage {
115 message: &'static str,
119 pub(crate) const fn new(kind: ErrorKind, message: &'static str) -> Self {
120 Self { kind, message }
124 /// Create and return an `io::Error` for a given `ErrorKind` and constant
125 /// message. This doesn't allocate.
126 pub(crate) macro const_io_error($kind:expr, $message:expr $(,)?) {
127 $crate::io::error::Error::from_static_message({
128 const MESSAGE_DATA: $crate::io::error::SimpleMessage =
129 $crate::io::error::SimpleMessage::new($kind, $message);
134 // As with `SimpleMessage`: `#[repr(align(4))]` here is just because
135 // repr_bitpacked's encoding requires it. In practice it almost certainly be
136 // already be this high or higher.
141 error: Box<dyn error::Error + Send + Sync>,
144 /// A list specifying general categories of I/O error.
146 /// This list is intended to grow over time and it is not recommended to
147 /// exhaustively match against it.
149 /// It is used with the [`io::Error`] type.
151 /// [`io::Error`]: Error
153 /// # Handling errors and matching on `ErrorKind`
155 /// In application code, use `match` for the `ErrorKind` values you are
156 /// expecting; use `_` to match "all other errors".
158 /// In comprehensive and thorough tests that want to verify that a test doesn't
159 /// return any known incorrect error kind, you may want to cut-and-paste the
160 /// current full list of errors from here into your test code, and then match
161 /// `_` as the correct case. This seems counterintuitive, but it will make your
162 /// tests more robust. In particular, if you want to verify that your code does
163 /// produce an unrecognized error kind, the robust solution is to check for all
164 /// the recognized error kinds and fail in those cases.
165 #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
166 #[stable(feature = "rust1", since = "1.0.0")]
170 /// An entity was not found, often a file.
171 #[stable(feature = "rust1", since = "1.0.0")]
173 /// The operation lacked the necessary privileges to complete.
174 #[stable(feature = "rust1", since = "1.0.0")]
176 /// The connection was refused by the remote server.
177 #[stable(feature = "rust1", since = "1.0.0")]
179 /// The connection was reset by the remote server.
180 #[stable(feature = "rust1", since = "1.0.0")]
182 /// The remote host is not reachable.
183 #[unstable(feature = "io_error_more", issue = "86442")]
185 /// The network containing the remote host is not reachable.
186 #[unstable(feature = "io_error_more", issue = "86442")]
188 /// The connection was aborted (terminated) by the remote server.
189 #[stable(feature = "rust1", since = "1.0.0")]
191 /// The network operation failed because it was not connected yet.
192 #[stable(feature = "rust1", since = "1.0.0")]
194 /// A socket address could not be bound because the address is already in
196 #[stable(feature = "rust1", since = "1.0.0")]
198 /// A nonexistent interface was requested or the requested address was not
200 #[stable(feature = "rust1", since = "1.0.0")]
202 /// The system's networking is down.
203 #[unstable(feature = "io_error_more", issue = "86442")]
205 /// The operation failed because a pipe was closed.
206 #[stable(feature = "rust1", since = "1.0.0")]
208 /// An entity already exists, often a file.
209 #[stable(feature = "rust1", since = "1.0.0")]
211 /// The operation needs to block to complete, but the blocking operation was
212 /// requested to not occur.
213 #[stable(feature = "rust1", since = "1.0.0")]
215 /// A filesystem object is, unexpectedly, not a directory.
217 /// For example, a filesystem path was specified where one of the intermediate directory
218 /// components was, in fact, a plain file.
219 #[unstable(feature = "io_error_more", issue = "86442")]
221 /// The filesystem object is, unexpectedly, a directory.
223 /// A directory was specified when a non-directory was expected.
224 #[unstable(feature = "io_error_more", issue = "86442")]
226 /// A non-empty directory was specified where an empty directory was expected.
227 #[unstable(feature = "io_error_more", issue = "86442")]
229 /// The filesystem or storage medium is read-only, but a write operation was attempted.
230 #[unstable(feature = "io_error_more", issue = "86442")]
232 /// Loop in the filesystem or IO subsystem; often, too many levels of symbolic links.
234 /// There was a loop (or excessively long chain) resolving a filesystem object
235 /// or file IO object.
237 /// On Unix this is usually the result of a symbolic link loop; or, of exceeding the
238 /// system-specific limit on the depth of symlink traversal.
239 #[unstable(feature = "io_error_more", issue = "86442")]
241 /// Stale network file handle.
243 /// With some network filesystems, notably NFS, an open file (or directory) can be invalidated
244 /// by problems with the network or server.
245 #[unstable(feature = "io_error_more", issue = "86442")]
246 StaleNetworkFileHandle,
247 /// A parameter was incorrect.
248 #[stable(feature = "rust1", since = "1.0.0")]
250 /// Data not valid for the operation were encountered.
252 /// Unlike [`InvalidInput`], this typically means that the operation
253 /// parameters were valid, however the error was caused by malformed
256 /// For example, a function that reads a file into a string will error with
257 /// `InvalidData` if the file's contents are not valid UTF-8.
259 /// [`InvalidInput`]: ErrorKind::InvalidInput
260 #[stable(feature = "io_invalid_data", since = "1.2.0")]
262 /// The I/O operation's timeout expired, causing it to be canceled.
263 #[stable(feature = "rust1", since = "1.0.0")]
265 /// An error returned when an operation could not be completed because a
266 /// call to [`write`] returned [`Ok(0)`].
268 /// This typically means that an operation could only succeed if it wrote a
269 /// particular number of bytes but only a smaller number of bytes could be
272 /// [`write`]: crate::io::Write::write
274 #[stable(feature = "rust1", since = "1.0.0")]
276 /// The underlying storage (typically, a filesystem) is full.
278 /// This does not include out of quota errors.
279 #[unstable(feature = "io_error_more", issue = "86442")]
281 /// Seek on unseekable file.
283 /// Seeking was attempted on an open file handle which is not suitable for seeking - for
284 /// example, on Unix, a named pipe opened with `File::open`.
285 #[unstable(feature = "io_error_more", issue = "86442")]
287 /// Filesystem quota was exceeded.
288 #[unstable(feature = "io_error_more", issue = "86442")]
289 FilesystemQuotaExceeded,
290 /// File larger than allowed or supported.
292 /// This might arise from a hard limit of the underlying filesystem or file access API, or from
293 /// an administratively imposed resource limitation. Simple disk full, and out of quota, have
294 /// their own errors.
295 #[unstable(feature = "io_error_more", issue = "86442")]
297 /// Resource is busy.
298 #[unstable(feature = "io_error_more", issue = "86442")]
300 /// Executable file is busy.
302 /// An attempt was made to write to a file which is also in use as a running program. (Not all
303 /// operating systems detect this situation.)
304 #[unstable(feature = "io_error_more", issue = "86442")]
306 /// Deadlock (avoided).
308 /// A file locking operation would result in deadlock. This situation is typically detected, if
309 /// at all, on a best-effort basis.
310 #[unstable(feature = "io_error_more", issue = "86442")]
312 /// Cross-device or cross-filesystem (hard) link or rename.
313 #[unstable(feature = "io_error_more", issue = "86442")]
315 /// Too many (hard) links to the same filesystem object.
317 /// The filesystem does not support making so many hardlinks to the same file.
318 #[unstable(feature = "io_error_more", issue = "86442")]
320 /// A filename was invalid.
322 /// This error can also cause if it exceeded the filename length limit.
323 #[unstable(feature = "io_error_more", issue = "86442")]
325 /// Program argument list too long.
327 /// When trying to run an external program, a system or process limit on the size of the
328 /// arguments would have been exceeded.
329 #[unstable(feature = "io_error_more", issue = "86442")]
331 /// This operation was interrupted.
333 /// Interrupted operations can typically be retried.
334 #[stable(feature = "rust1", since = "1.0.0")]
337 /// This operation is unsupported on this platform.
339 /// This means that the operation can never succeed.
340 #[stable(feature = "unsupported_error", since = "1.53.0")]
343 // ErrorKinds which are primarily categorisations for OS error
344 // codes should be added above.
346 /// An error returned when an operation could not be completed because an
347 /// "end of file" was reached prematurely.
349 /// This typically means that an operation could only succeed if it read a
350 /// particular number of bytes but only a smaller number of bytes could be
352 #[stable(feature = "read_exact", since = "1.6.0")]
355 /// An operation could not be completed, because it failed
356 /// to allocate enough memory.
357 #[stable(feature = "out_of_memory_error", since = "1.54.0")]
360 // "Unusual" error kinds which do not correspond simply to (sets
361 // of) OS error codes, should be added just above this comment.
362 // `Other` and `Uncategorised` should remain at the end:
364 /// A custom error that does not fall under any other I/O error kind.
366 /// This can be used to construct your own [`Error`]s that do not match any
369 /// This [`ErrorKind`] is not used by the standard library.
371 /// Errors from the standard library that do not fall under any of the I/O
372 /// error kinds cannot be `match`ed on, and will only match a wildcard (`_`) pattern.
373 /// New [`ErrorKind`]s might be added in the future for some of those.
374 #[stable(feature = "rust1", since = "1.0.0")]
377 /// Any I/O error from the standard library that's not part of this list.
379 /// Errors that are `Uncategorized` now may move to a different or a new
380 /// [`ErrorKind`] variant in the future. It is not recommended to match
381 /// an error against `Uncategorized`; use a wildcard match (`_`) instead.
382 #[unstable(feature = "io_error_uncategorized", issue = "none")]
388 pub(crate) fn as_str(&self) -> &'static str {
390 // tidy-alphabetical-start
392 AddrInUse => "address in use",
393 AddrNotAvailable => "address not available",
394 AlreadyExists => "entity already exists",
395 ArgumentListTooLong => "argument list too long",
396 BrokenPipe => "broken pipe",
397 ConnectionAborted => "connection aborted",
398 ConnectionRefused => "connection refused",
399 ConnectionReset => "connection reset",
400 CrossesDevices => "cross-device link or rename",
401 Deadlock => "deadlock",
402 DirectoryNotEmpty => "directory not empty",
403 ExecutableFileBusy => "executable file busy",
404 FileTooLarge => "file too large",
405 FilesystemLoop => "filesystem loop or indirection limit (e.g. symlink loop)",
406 FilesystemQuotaExceeded => "filesystem quota exceeded",
407 HostUnreachable => "host unreachable",
408 Interrupted => "operation interrupted",
409 InvalidData => "invalid data",
410 InvalidFilename => "invalid filename",
411 InvalidInput => "invalid input parameter",
412 IsADirectory => "is a directory",
413 NetworkDown => "network down",
414 NetworkUnreachable => "network unreachable",
415 NotADirectory => "not a directory",
416 NotConnected => "not connected",
417 NotFound => "entity not found",
418 NotSeekable => "seek on unseekable file",
419 Other => "other error",
420 OutOfMemory => "out of memory",
421 PermissionDenied => "permission denied",
422 ReadOnlyFilesystem => "read-only filesystem or storage medium",
423 ResourceBusy => "resource busy",
424 StaleNetworkFileHandle => "stale network file handle",
425 StorageFull => "no storage space",
426 TimedOut => "timed out",
427 TooManyLinks => "too many links",
428 Uncategorized => "uncategorized error",
429 UnexpectedEof => "unexpected end of file",
430 Unsupported => "unsupported",
431 WouldBlock => "operation would block",
432 WriteZero => "write zero",
434 // tidy-alphabetical-end
438 #[stable(feature = "io_errorkind_display", since = "1.60.0")]
439 impl fmt::Display for ErrorKind {
440 /// Shows a human-readable description of the `ErrorKind`.
442 /// This is similar to `impl Display for Error`, but doesn't require first converting to Error.
446 /// use std::io::ErrorKind;
447 /// assert_eq!("entity not found", ErrorKind::NotFound.to_string());
449 fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
450 fmt.write_str(self.as_str())
454 /// Intended for use for errors not exposed to the user, where allocating onto
455 /// the heap (for normal construction via Error::new) is too costly.
456 #[stable(feature = "io_error_from_errorkind", since = "1.14.0")]
457 impl From<ErrorKind> for Error {
458 /// Converts an [`ErrorKind`] into an [`Error`].
460 /// This conversion creates a new error with a simple representation of error kind.
465 /// use std::io::{Error, ErrorKind};
467 /// let not_found = ErrorKind::NotFound;
468 /// let error = Error::from(not_found);
469 /// assert_eq!("entity not found", format!("{error}"));
472 fn from(kind: ErrorKind) -> Error {
473 Error { repr: Repr::new_simple(kind) }
478 /// Creates a new I/O error from a known kind of error as well as an
479 /// arbitrary error payload.
481 /// This function is used to generically create I/O errors which do not
482 /// originate from the OS itself. The `error` argument is an arbitrary
483 /// payload which will be contained in this [`Error`].
485 /// Note that this function allocates memory on the heap.
486 /// If no extra payload is required, use the `From` conversion from
492 /// use std::io::{Error, ErrorKind};
494 /// // errors can be created from strings
495 /// let custom_error = Error::new(ErrorKind::Other, "oh no!");
497 /// // errors can also be created from other errors
498 /// let custom_error2 = Error::new(ErrorKind::Interrupted, custom_error);
500 /// // creating an error without payload (and without memory allocation)
501 /// let eof_error = Error::from(ErrorKind::UnexpectedEof);
503 #[stable(feature = "rust1", since = "1.0.0")]
504 pub fn new<E>(kind: ErrorKind, error: E) -> Error
506 E: Into<Box<dyn error::Error + Send + Sync>>,
508 Self::_new(kind, error.into())
511 /// Creates a new I/O error from an arbitrary error payload.
513 /// This function is used to generically create I/O errors which do not
514 /// originate from the OS itself. It is a shortcut for [`Error::new`]
515 /// with [`ErrorKind::Other`].
520 /// #![feature(io_error_other)]
522 /// use std::io::Error;
524 /// // errors can be created from strings
525 /// let custom_error = Error::other("oh no!");
527 /// // errors can also be created from other errors
528 /// let custom_error2 = Error::other(custom_error);
530 #[unstable(feature = "io_error_other", issue = "91946")]
531 pub fn other<E>(error: E) -> Error
533 E: Into<Box<dyn error::Error + Send + Sync>>,
535 Self::_new(ErrorKind::Other, error.into())
538 fn _new(kind: ErrorKind, error: Box<dyn error::Error + Send + Sync>) -> Error {
539 Error { repr: Repr::new_custom(Box::new(Custom { kind, error })) }
542 /// Creates a new I/O error from a known kind of error as well as a constant
545 /// This function does not allocate.
547 /// You should not use this directly, and instead use the `const_io_error!`
548 /// macro: `io::const_io_error!(ErrorKind::Something, "some_message")`.
550 /// This function should maybe change to `from_static_message<const MSG: &'static
551 /// str>(kind: ErrorKind)` in the future, when const generics allow that.
553 pub(crate) const fn from_static_message(msg: &'static SimpleMessage) -> Error {
554 Self { repr: Repr::new_simple_message(msg) }
557 /// Returns an error representing the last OS error which occurred.
559 /// This function reads the value of `errno` for the target platform (e.g.
560 /// `GetLastError` on Windows) and will return a corresponding instance of
561 /// [`Error`] for the error code.
563 /// This should be called immediately after a call to a platform function,
564 /// otherwise the state of the error value is indeterminate. In particular,
565 /// other standard library functions may call platform functions that may
566 /// (or may not) reset the error value even if they succeed.
571 /// use std::io::Error;
573 /// let os_error = Error::last_os_error();
574 /// println!("last OS error: {os_error:?}");
576 #[stable(feature = "rust1", since = "1.0.0")]
577 #[doc(alias = "GetLastError")]
578 #[doc(alias = "errno")]
581 pub fn last_os_error() -> Error {
582 Error::from_raw_os_error(sys::os::errno() as i32)
585 /// Creates a new instance of an [`Error`] from a particular OS error code.
592 /// # if cfg!(target_os = "linux") {
595 /// let error = io::Error::from_raw_os_error(22);
596 /// assert_eq!(error.kind(), io::ErrorKind::InvalidInput);
603 /// # if cfg!(windows) {
606 /// let error = io::Error::from_raw_os_error(10022);
607 /// assert_eq!(error.kind(), io::ErrorKind::InvalidInput);
610 #[stable(feature = "rust1", since = "1.0.0")]
613 pub fn from_raw_os_error(code: i32) -> Error {
614 Error { repr: Repr::new_os(code) }
617 /// Returns the OS error that this error represents (if any).
619 /// If this [`Error`] was constructed via [`last_os_error`] or
620 /// [`from_raw_os_error`], then this function will return [`Some`], otherwise
621 /// it will return [`None`].
623 /// [`last_os_error`]: Error::last_os_error
624 /// [`from_raw_os_error`]: Error::from_raw_os_error
629 /// use std::io::{Error, ErrorKind};
631 /// fn print_os_error(err: &Error) {
632 /// if let Some(raw_os_err) = err.raw_os_error() {
633 /// println!("raw OS error: {raw_os_err:?}");
635 /// println!("Not an OS error");
640 /// // Will print "raw OS error: ...".
641 /// print_os_error(&Error::last_os_error());
642 /// // Will print "Not an OS error".
643 /// print_os_error(&Error::new(ErrorKind::Other, "oh no!"));
646 #[stable(feature = "rust1", since = "1.0.0")]
649 pub fn raw_os_error(&self) -> Option<i32> {
650 match self.repr.data() {
651 ErrorData::Os(i) => Some(i),
652 ErrorData::Custom(..) => None,
653 ErrorData::Simple(..) => None,
654 ErrorData::SimpleMessage(..) => None,
658 /// Returns a reference to the inner error wrapped by this error (if any).
660 /// If this [`Error`] was constructed via [`new`] then this function will
661 /// return [`Some`], otherwise it will return [`None`].
663 /// [`new`]: Error::new
668 /// use std::io::{Error, ErrorKind};
670 /// fn print_error(err: &Error) {
671 /// if let Some(inner_err) = err.get_ref() {
672 /// println!("Inner error: {inner_err:?}");
674 /// println!("No inner error");
679 /// // Will print "No inner error".
680 /// print_error(&Error::last_os_error());
681 /// // Will print "Inner error: ...".
682 /// print_error(&Error::new(ErrorKind::Other, "oh no!"));
685 #[stable(feature = "io_error_inner", since = "1.3.0")]
688 pub fn get_ref(&self) -> Option<&(dyn error::Error + Send + Sync + 'static)> {
689 match self.repr.data() {
690 ErrorData::Os(..) => None,
691 ErrorData::Simple(..) => None,
692 ErrorData::SimpleMessage(..) => None,
693 ErrorData::Custom(c) => Some(&*c.error),
697 /// Returns a mutable reference to the inner error wrapped by this error
700 /// If this [`Error`] was constructed via [`new`] then this function will
701 /// return [`Some`], otherwise it will return [`None`].
703 /// [`new`]: Error::new
708 /// use std::io::{Error, ErrorKind};
709 /// use std::{error, fmt};
710 /// use std::fmt::Display;
718 /// fn new() -> MyError {
720 /// v: "oh no!".to_string()
724 /// fn change_message(&mut self, new_message: &str) {
725 /// self.v = new_message.to_string();
729 /// impl error::Error for MyError {}
731 /// impl Display for MyError {
732 /// fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
733 /// write!(f, "MyError: {}", &self.v)
737 /// fn change_error(mut err: Error) -> Error {
738 /// if let Some(inner_err) = err.get_mut() {
739 /// inner_err.downcast_mut::<MyError>().unwrap().change_message("I've been changed!");
744 /// fn print_error(err: &Error) {
745 /// if let Some(inner_err) = err.get_ref() {
746 /// println!("Inner error: {inner_err}");
748 /// println!("No inner error");
753 /// // Will print "No inner error".
754 /// print_error(&change_error(Error::last_os_error()));
755 /// // Will print "Inner error: ...".
756 /// print_error(&change_error(Error::new(ErrorKind::Other, MyError::new())));
759 #[stable(feature = "io_error_inner", since = "1.3.0")]
762 pub fn get_mut(&mut self) -> Option<&mut (dyn error::Error + Send + Sync + 'static)> {
763 match self.repr.data_mut() {
764 ErrorData::Os(..) => None,
765 ErrorData::Simple(..) => None,
766 ErrorData::SimpleMessage(..) => None,
767 ErrorData::Custom(c) => Some(&mut *c.error),
771 /// Consumes the `Error`, returning its inner error (if any).
773 /// If this [`Error`] was constructed via [`new`] then this function will
774 /// return [`Some`], otherwise it will return [`None`].
776 /// [`new`]: Error::new
781 /// use std::io::{Error, ErrorKind};
783 /// fn print_error(err: Error) {
784 /// if let Some(inner_err) = err.into_inner() {
785 /// println!("Inner error: {inner_err}");
787 /// println!("No inner error");
792 /// // Will print "No inner error".
793 /// print_error(Error::last_os_error());
794 /// // Will print "Inner error: ...".
795 /// print_error(Error::new(ErrorKind::Other, "oh no!"));
798 #[stable(feature = "io_error_inner", since = "1.3.0")]
799 #[must_use = "`self` will be dropped if the result is not used"]
801 pub fn into_inner(self) -> Option<Box<dyn error::Error + Send + Sync>> {
802 match self.repr.into_data() {
803 ErrorData::Os(..) => None,
804 ErrorData::Simple(..) => None,
805 ErrorData::SimpleMessage(..) => None,
806 ErrorData::Custom(c) => Some(c.error),
810 /// Attempt to downgrade the inner error to `E` if any.
812 /// If this [`Error`] was constructed via [`new`] then this function will
813 /// attempt to perform downgrade on it, otherwise it will return [`Err`].
815 /// If downgrade succeeds, it will return [`Ok`], otherwise it will also
818 /// [`new`]: Error::new
823 /// #![feature(io_error_downcast)]
827 /// use std::error::Error;
832 /// SomeOtherVariant,
835 /// impl fmt::Display for E {
837 /// # fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
841 /// impl Error for E {}
843 /// impl From<io::Error> for E {
844 /// fn from(err: io::Error) -> E {
845 /// err.downcast::<E>()
847 /// .unwrap_or_else(E::Io)
851 #[unstable(feature = "io_error_downcast", issue = "99262")]
852 pub fn downcast<E>(self) -> result::Result<Box<E>, Self>
854 E: error::Error + Send + Sync + 'static,
856 match self.repr.into_data() {
857 ErrorData::Custom(b) if b.error.is::<E>() => {
858 let res = (*b).error.downcast::<E>();
860 // downcast is a really trivial and is marked as inline, so
861 // it's likely be inlined here.
863 // And the compiler should be able to eliminate the branch
864 // that produces `Err` here since b.error.is::<E>()
868 repr_data => Err(Self { repr: Repr::new(repr_data) }),
872 /// Returns the corresponding [`ErrorKind`] for this error.
877 /// use std::io::{Error, ErrorKind};
879 /// fn print_error(err: Error) {
880 /// println!("{:?}", err.kind());
884 /// // Will print "Uncategorized".
885 /// print_error(Error::last_os_error());
886 /// // Will print "AddrInUse".
887 /// print_error(Error::new(ErrorKind::AddrInUse, "oh no!"));
890 #[stable(feature = "rust1", since = "1.0.0")]
893 pub fn kind(&self) -> ErrorKind {
894 match self.repr.data() {
895 ErrorData::Os(code) => sys::decode_error_kind(code),
896 ErrorData::Custom(c) => c.kind,
897 ErrorData::Simple(kind) => kind,
898 ErrorData::SimpleMessage(m) => m.kind,
903 impl fmt::Debug for Repr {
904 fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
906 ErrorData::Os(code) => fmt
908 .field("code", &code)
909 .field("kind", &sys::decode_error_kind(code))
910 .field("message", &sys::os::error_string(code))
912 ErrorData::Custom(c) => fmt::Debug::fmt(&c, fmt),
913 ErrorData::Simple(kind) => fmt.debug_tuple("Kind").field(&kind).finish(),
914 ErrorData::SimpleMessage(msg) => fmt
915 .debug_struct("Error")
916 .field("kind", &msg.kind)
917 .field("message", &msg.message)
923 #[stable(feature = "rust1", since = "1.0.0")]
924 impl fmt::Display for Error {
925 fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
926 match self.repr.data() {
927 ErrorData::Os(code) => {
928 let detail = sys::os::error_string(code);
929 write!(fmt, "{detail} (os error {code})")
931 ErrorData::Custom(ref c) => c.error.fmt(fmt),
932 ErrorData::Simple(kind) => write!(fmt, "{}", kind.as_str()),
933 ErrorData::SimpleMessage(msg) => msg.message.fmt(fmt),
938 #[stable(feature = "rust1", since = "1.0.0")]
939 impl error::Error for Error {
940 #[allow(deprecated, deprecated_in_future)]
941 fn description(&self) -> &str {
942 match self.repr.data() {
943 ErrorData::Os(..) | ErrorData::Simple(..) => self.kind().as_str(),
944 ErrorData::SimpleMessage(msg) => msg.message,
945 ErrorData::Custom(c) => c.error.description(),
950 fn cause(&self) -> Option<&dyn error::Error> {
951 match self.repr.data() {
952 ErrorData::Os(..) => None,
953 ErrorData::Simple(..) => None,
954 ErrorData::SimpleMessage(..) => None,
955 ErrorData::Custom(c) => c.error.cause(),
959 fn source(&self) -> Option<&(dyn error::Error + 'static)> {
960 match self.repr.data() {
961 ErrorData::Os(..) => None,
962 ErrorData::Simple(..) => None,
963 ErrorData::SimpleMessage(..) => None,
964 ErrorData::Custom(c) => c.error.source(),
969 fn _assert_error_is_sync_send() {
970 fn _is_sync_send<T: Sync + Send>() {}
971 _is_sync_send::<Error>();