shuf: Prepare dropping release-fast profile

Author: oech3

src/uu/shuf/src/shuf.rs

@@ -378,6 +378,7 @@ impl Writable for &OsStr {
 }
 
 impl Writable for u64 {
+    #[inline]
     fn write_all_to(&self, output: &mut impl OsWrite) -> Result<(), Error> {
         // The itoa crate is surprisingly much more efficient than a formatted write.
         // It speeds up `shuf -r -n1000000 -i1-1024` by 1.8×.
@@ -386,13 +387,23 @@ impl Writable for u64 {
     }
 }
 
+#[cold]
+#[inline(never)]
+fn crash(e: std::io::Error) -> Box<dyn uucore::error::UError> {
+    use uucore::error::FromIo;
+    let ctx = translate!("shuf-error-write-failed");
+    e.map_err_context(move || ctx)
+}
+
+#[inline(never)]
 fn shuf_exec(
     input: &mut impl Shufable,
     opts: &Options,
     rng: &mut WrappedRng,
     output: &mut BufWriter<Box<dyn OsWrite>>,
 ) -> UResult<()> {
     let ctx = || translate!("shuf-error-write-failed");
+    let sep = [opts.sep];
     if opts.repeat {
         if input.is_empty() {
             return Err(USimpleError::new(
@@ -402,17 +413,21 @@ fn shuf_exec(
         }
         for _ in 0..opts.head_count {
             let r = input.choose(rng)?;
-
-            r.write_all_to(output).map_err_context(ctx)?;
-            output.write_all(&[opts.sep]).map_err_context(ctx)?;
+            if let Err(e) = r.write_all_to(output) {
+                return Err(crash(e));
+            }
+            if let Err(e) = output.write_all(&sep) {
+                return Err(crash(e));
+            }
         }
     } else {
         let shuffled = input.partial_shuffle(rng, opts.head_count)?;
+        let sep = [opts.sep];
 
         for r in shuffled {
             let r = r?;
-            r.write_all_to(output).map_err_context(ctx)?;
-            output.write_all(&[opts.sep]).map_err_context(ctx)?;
+            r.write_all_to(output).map_err(crash)?;
+            output.write_all(&sep).map_err(crash)?;
         }
     }
     output.flush().map_err_context(ctx)?;

src/uucore/src/lib/mods/error.rs

@@ -407,56 +407,65 @@ impl Error for UIoError {}
 
 impl Display for UIoError {
     fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
-        use std::io::ErrorKind::*;
-
-        let message;
-        let message = if self.inner.raw_os_error().is_some() {
-            // These are errors that come directly from the OS.
-            // We want to normalize their messages across systems,
-            // and we want to strip the "(os error X)" suffix.
-            match self.inner.kind() {
-                NotFound => "No such file or directory",
-                PermissionDenied => "Permission denied",
-                ConnectionRefused => "Connection refused",
-                ConnectionReset => "Connection reset",
-                ConnectionAborted => "Connection aborted",
-                NotConnected => "Not connected",
-                AddrInUse => "Address in use",
-                AddrNotAvailable => "Address not available",
-                BrokenPipe => "Broken pipe",
-                AlreadyExists => "Already exists",
-                WouldBlock => "Would block",
-                InvalidInput => "Invalid input",
-                InvalidData => "Invalid data",
-                TimedOut => "Timed out",
-                WriteZero => "Write zero",
-                Interrupted => "Interrupted",
-                UnexpectedEof => "Unexpected end of file",
-                _ => {
-                    // TODO: When the new error variants
-                    // (https://github.com/rust-lang/rust/issues/86442)
-                    // are stabilized, we should add them to the match statement.
-                    message = strip_errno(&self.inner);
-                    &message
-                }
+        cold_io_error(f, self.context.as_ref(), &self.inner)
+    }
+}
+
+#[cold] //for codegen-units=1
+#[inline(never)]
+fn cold_io_error(
+    f: &mut Formatter<'_>,
+    ctx: Option<&String>,
+    inner: &std::io::Error,
+) -> Result<(), std::fmt::Error> {
+    use std::io::ErrorKind::*;
+
+    let message_hold;
+    let message = if inner.raw_os_error().is_some() {
+        // These are errors that come directly from the OS.
+        // We want to normalize their messages across systems,
+        // and we want to strip the "(os error X)" suffix.
+        match inner.kind() {
+            NotFound => "No such file or directory",
+            PermissionDenied => "Permission denied",
+            ConnectionRefused => "Connection refused",
+            ConnectionReset => "Connection reset",
+            ConnectionAborted => "Connection aborted",
+            NotConnected => "Not connected",
+            AddrInUse => "Address in use",
+            AddrNotAvailable => "Address not available",
+            BrokenPipe => "Broken pipe",
+            AlreadyExists => "Already exists",
+            WouldBlock => "Would block",
+            InvalidInput => "Invalid input",
+            InvalidData => "Invalid data",
+            TimedOut => "Timed out",
+            WriteZero => "Write zero",
+            Interrupted => "Interrupted",
+            UnexpectedEof => "Unexpected end of file",
+            _ => {
+                // TODO: When the new error variants
+                // (https://github.com/rust-lang/rust/issues/86442)
+                // are stabilized, we should add them to the match statement.
+                message_hold = strip_errno(inner);
+                &message_hold
             }
-        } else {
-            // These messages don't need as much normalization, and the above
-            // messages wouldn't always be a good substitute.
-            // For example, ErrorKind::NotFound doesn't necessarily mean it was
-            // a file that was not found.
-            // There are also errors with entirely custom messages.
-            message = self.inner.to_string();
-            &message
-        };
-        if let Some(ctx) = &self.context {
-            write!(f, "{ctx}: {message}")
-        } else {
-            write!(f, "{message}")
         }
+    } else {
+        // These messages don't need as much normalization, and the above
+        // messages wouldn't always be a good substitute.
+        // For example, ErrorKind::NotFound doesn't necessarily mean it was
+        // a file that was not found.
+        // There are also errors with entirely custom messages.
+        message_hold = inner.to_string();
+        &message_hold
+    };
+    if let Some(c) = ctx {
+        write!(f, "{c}: {message}")
+    } else {
+        write!(f, "{message}")
     }
 }
-
 /// Strip the trailing " (os error XX)" from io error strings.
 pub fn strip_errno(err: &std::io::Error) -> String {
     let mut msg = err.to_string();