Move io::Error to alloc

Author: a1phyr

library/std/src/io/error.rs library/alloc/src/io/error.rslibrary/std/src/io/error.rs renamed to library/alloc/src/io/error.rs

@@ -107,6 +107,7 @@ use core::num::NonZeroUsize;
 use core::ptr::NonNull;
 
 use super::{Custom, ErrorData, ErrorKind, RawOsError, SimpleMessage};
+use crate::boxed::Box;
 
 // The 2 least-significant bits are used as tag.
 const TAG_MASK: usize = 0b11;

…brary/std/src/io/error/repr_bitpacked.rs …ary/alloc/src/io/error/repr_bitpacked.rslibrary/std/src/io/error/repr_bitpacked.rs renamed to library/alloc/src/io/error/repr_bitpacked.rs library/std/src/io/error/repr_bitpacked.rs renamed to library/alloc/src/io/error/repr_bitpacked.rs

@@ -3,6 +3,7 @@
 //! would have no benefit.
 
 use super::{Custom, ErrorData, ErrorKind, RawOsError, SimpleMessage};
+use crate::boxed::Box;
 
 type Inner = ErrorData<Box<Custom>>;
 

library/std/src/io/error/repr_unpacked.rs …rary/alloc/src/io/error/repr_unpacked.rslibrary/std/src/io/error/repr_unpacked.rs renamed to library/alloc/src/io/error/repr_unpacked.rs library/std/src/io/error/repr_unpacked.rs renamed to library/alloc/src/io/error/repr_unpacked.rs

@@ -0,0 +1,17 @@
+//! Traits, helpers, and type definitions for core I/O functionality.
+
+#[unstable(feature = "read_buf", issue = "78485")]
+pub use core::io::{BorrowedBuf, BorrowedCursor};
+
+#[doc(hidden)]
+#[unstable(feature = "io_const_error_internals", issue = "none")]
+pub use self::error::SimpleMessage;
+#[unstable(feature = "io_const_error", issue = "133448")]
+pub use self::error::const_error;
+#[stable(feature = "rust1", since = "1.0.0")]
+pub use self::error::{Error, ErrorKind, Result};
+#[unstable(feature = "io_error_internals", issue = "none")]
+#[doc(hidden)]
+pub use self::error::{RawOsError, os::OsFunctions};
+
+mod error;

library/alloc/src/io/mod.rs

@@ -63,7 +63,10 @@
 #![doc(
     html_playground_url = "https://play.rust-lang.org/",
     issue_tracker_base_url = "https://github.com/rust-lang/rust/issues/",
-    test(no_crate_inject, attr(allow(unused_variables, duplicate_features), deny(warnings)))
+    test(
+        no_crate_inject,
+        attr(allow(unused_variables, duplicate_features, dead_code), deny(warnings))
+    )
 )]
 #![doc(auto_cfg(hide(no_global_oom_handling, no_rc, no_sync, target_has_atomic = "ptr")))]
 #![doc(rust_logo)]
@@ -86,6 +89,7 @@
 //
 // Library features:
 // tidy-alphabetical-start
+#![cfg_attr(not(no_global_oom_handling), feature(io_const_error))]
 #![feature(allocator_api)]
 #![feature(array_into_iter_constructors)]
 #![feature(ascii_char)]
@@ -224,6 +228,9 @@ pub mod collections;
 pub mod ffi;
 pub mod fmt;
 pub mod intrinsics;
+#[unstable(feature = "alloc_io", issue = "154046")]
+#[cfg(not(no_global_oom_handling))]
+pub mod io;
 #[cfg(not(no_rc))]
 pub mod rc;
 pub mod slice;

library/alloc/src/lib.rs

@@ -0,0 +1,115 @@
+//! OS-dependent public methods of `Error`
+
+#[cfg(test)]
+mod tests;
+
+#[cfg(not(test))]
+use alloc::io::{Error, RawOsError};
+
+// FIXME: for some reason, enabling these in `test` config makes them defined twice,
+// but it does not seem to be the case with other incoherent items.
+#[cfg(not(test))]
+impl Error {
+    /// 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]
+    #[rustc_allow_incoherent_impl]
+    pub fn from_raw_os_error(code: RawOsError) -> Error {
+        Error::_from_raw_os_error(
+            code,
+            &alloc::io::OsFunctions {
+                error_string: crate::sys::io::error_string,
+                decode_error_kind: crate::sys::io::decode_error_kind,
+                is_interrupted: crate::sys::io::is_interrupted,
+            },
+        )
+    }
+
+    /// 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`].
+    ///
+    /// # 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]
+    #[rustc_allow_incoherent_impl]
+    pub fn raw_os_error(&self) -> Option<RawOsError> {
+        self._raw_os_error()
+    }
+
+    /// 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")]
+    #[doc(alias = "GetLastError")]
+    #[doc(alias = "errno")]
+    #[must_use]
+    #[inline]
+    #[rustc_allow_incoherent_impl]
+    pub fn last_os_error() -> Error {
+        Error::from_raw_os_error(crate::sys::io::errno())
+    }
+}

library/std/src/io/error/mod.rs

@@ -1,6 +1,12 @@
-use super::{Custom, Error, ErrorData, ErrorKind, Repr, SimpleMessage, const_error};
+use crate::io::{Error, ErrorKind, const_error};
 use crate::sys::io::{decode_error_kind, error_string};
-use crate::{assert_matches, error, fmt};
+use crate::{error, fmt};
+
+// Make sure that all these are used even when running tests
+#[cfg(test)]
+const _: () = {
+    let _ = (crate::sys::io::errno, crate::sys::io::is_interrupted);
+};
 
 #[test]
 fn test_size() {
@@ -12,12 +18,9 @@ fn test_debug_error() {
     let code = 6;
     let msg = error_string(code);
     let kind = decode_error_kind(code);
-    let err = Error {
-        repr: Repr::new_custom(Box::new(Custom {
-            kind: ErrorKind::InvalidInput,
-            error: Box::new(Error { repr: super::Repr::new_os(code) }),
-        })),
-    };
+
+    let err = Error::new(ErrorKind::InvalidInput, Error::from_raw_os_error(code));
+
     let expected = format!(
         "Custom {{ \
          kind: InvalidInput, \
@@ -30,6 +33,15 @@ fn test_debug_error() {
         code, kind, msg
     );
     assert_eq!(format!("{err:?}"), expected);
+
+    let err = Error::from(ErrorKind::AddrInUse);
+    assert_eq!(format!("{err:?}"), "Kind(AddrInUse)");
+
+    let err = Error::READ_EXACT_EOF;
+    assert_eq!(
+        format!("{err:?}"),
+        "Error { kind: UnexpectedEof, message: \"failed to fill whole buffer\" }"
+    );
 }
 
 #[test]
@@ -70,10 +82,6 @@ fn test_os_packing() {
     for code in -20..20 {
         let e = Error::from_raw_os_error(code);
         assert_eq!(e.raw_os_error(), Some(code));
-        assert_matches!(
-            e.repr.data(),
-            ErrorData::Os(c) if c == code,
-        );
     }
 }
 
@@ -82,28 +90,18 @@ fn test_errorkind_packing() {
     assert_eq!(Error::from(ErrorKind::NotFound).kind(), ErrorKind::NotFound);
     assert_eq!(Error::from(ErrorKind::PermissionDenied).kind(), ErrorKind::PermissionDenied);
     assert_eq!(Error::from(ErrorKind::Uncategorized).kind(), ErrorKind::Uncategorized);
-    // Check that the innards look like what we want.
-    assert_matches!(
-        Error::from(ErrorKind::OutOfMemory).repr.data(),
-        ErrorData::Simple(ErrorKind::OutOfMemory),
-    );
 }
 
 #[test]
 fn test_simple_message_packing() {
-    use super::ErrorKind::*;
-    use super::SimpleMessage;
+    use crate::io::ErrorKind::*;
     macro_rules! check_simple_msg {
         ($err:expr, $kind:ident, $msg:literal) => {{
             let e = &$err;
             // Check that the public api is right.
             assert_eq!(e.kind(), $kind);
             assert!(format!("{e:?}").contains($msg));
-            // and we got what we expected
-            assert_matches!(
-                e.repr.data(),
-                ErrorData::SimpleMessage(SimpleMessage { kind: $kind, message: $msg })
-            );
+            assert!(format!("{e}").contains($msg));
         }};
     }
 
@@ -126,19 +124,6 @@ impl fmt::Display for Bojji {
     }
 }
 
-#[test]
-fn test_custom_error_packing() {
-    use super::Custom;
-    let test = Error::new(ErrorKind::Uncategorized, Bojji(true));
-    assert_matches!(
-        test.repr.data(),
-        ErrorData::Custom(Custom {
-            kind: ErrorKind::Uncategorized,
-            error,
-        }) if error.downcast_ref::<Bojji>().as_deref() == Some(&Bojji(true)),
-    );
-}
-
 #[derive(Debug)]
 struct E;
 
@@ -181,11 +166,9 @@ fn test_std_io_error_downcast() {
     assert_eq!(kind, io_error.kind());
 
     // Case 5: simple message
-    const SIMPLE_MESSAGE: SimpleMessage =
-        SimpleMessage { kind: ErrorKind::Other, message: "simple message error test" };
-    let io_error = Error::from_static_message(&SIMPLE_MESSAGE);
+    let io_error = const_error!(ErrorKind::Other, "simple message error test");
     let io_error = io_error.downcast::<E>().unwrap_err();
 
-    assert_eq!(SIMPLE_MESSAGE.kind, io_error.kind());
-    assert_eq!(SIMPLE_MESSAGE.message, format!("{io_error}"));
+    assert_eq!(io_error.kind(), ErrorKind::Other);
+    assert_eq!(format!("{io_error}"), "simple message error test");
 }

library/std/src/io/error/tests.rs

@@ -297,19 +297,21 @@
 #[cfg(test)]
 mod tests;
 
+#[unstable(feature = "raw_os_error_ty", issue = "107792")]
+pub use alloc::io::RawOsError;
+#[doc(hidden)]
+#[unstable(feature = "io_const_error_internals", issue = "none")]
+pub use alloc::io::SimpleMessage;
+#[unstable(feature = "io_const_error", issue = "133448")]
+pub use alloc::io::const_error;
+#[stable(feature = "rust1", since = "1.0.0")]
+pub use alloc::io::{Error, ErrorKind, Result};
 #[unstable(feature = "read_buf", issue = "78485")]
 pub use core::io::{BorrowedBuf, BorrowedCursor};
 use core::slice::memchr;
 
 #[stable(feature = "bufwriter_into_parts", since = "1.56.0")]
 pub use self::buffered::WriterPanicked;
-#[unstable(feature = "raw_os_error_ty", issue = "107792")]
-pub use self::error::RawOsError;
-#[doc(hidden)]
-#[unstable(feature = "io_const_error_internals", issue = "none")]
-pub use self::error::SimpleMessage;
-#[unstable(feature = "io_const_error", issue = "133448")]
-pub use self::error::const_error;
 #[stable(feature = "anonymous_pipe", since = "1.87.0")]
 pub use self::pipe::{PipeReader, PipeWriter, pipe};
 #[stable(feature = "is_terminal", since = "1.70.0")]
@@ -326,7 +328,6 @@ pub use self::{
     buffered::{BufReader, BufWriter, IntoInnerError, LineWriter},
     copy::copy,
     cursor::Cursor,
-    error::{Error, ErrorKind, Result},
     stdio::{Stderr, StderrLock, Stdin, StdinLock, Stdout, StdoutLock, stderr, stdin, stdout},
     util::{Empty, Repeat, Sink, empty, repeat, sink},
 };

library/std/src/io/mod.rs

@@ -369,9 +369,14 @@
 //
 // Library features (alloc):
 // tidy-alphabetical-start
+#![feature(alloc_io)]
 #![feature(allocator_api)]
 #![feature(clone_from_ref)]
 #![feature(get_mut_unchecked)]
+#![feature(io_error_inprogress)]
+#![feature(io_error_internals)]
+#![feature(io_error_more)]
+#![feature(io_error_uncategorized)]
 #![feature(map_try_insert)]
 #![feature(slice_concat_trait)]
 #![feature(thin_box)]

library/std/src/lib.rs

@@ -48,8 +48,3 @@ cfg_select! {
         pub use generic::*;
     }
 }
-
-pub type RawOsError = cfg_select! {
-    target_os = "uefi" => usize,
-    _ => i32,
-};