unix: Relax escaping in Debug impl on Command

The Debug output of Command is very useful for showing to the user the
command that was executed when something went wrong. This is done for
example by rustc when invoking an external tool like the linker fails.

It is also overly verbose, since everything is quoted, which makes it
harder to read. Instead, we now first check if we're reasonably sure
that an argument is simple enough that using it in the shell wouldn't
need quoting, and then output it without quotes if possible.

Before and example output could look like this:

    PATH="/a:/b" "cc" "foo.o" "-target" "arm64-apple-darwin11.0"

Now it looks like this:

    PATH="/a:/b" cc foo.o -target arm64-apple-darwin11.0

Author: madsmtm

library/std/src/lib.rs

@@ -291,6 +291,7 @@
 #![feature(cfi_encoding)]
 #![feature(concat_idents)]
 #![feature(const_float_methods)]
+#![feature(debug_closure_helpers)]
 #![feature(decl_macro)]
 #![feature(deprecated_suggestion)]
 #![feature(doc_cfg)]

library/std/src/sys/pal/unix/process/process_common.rs

@@ -580,8 +580,29 @@ impl fmt::Debug for Command {
 
             debug_command.finish()
         } else {
+            /// Only escape arguments when necessary, otherwise output it
+            /// unescaped to make the output easier to read.
+            fn relaxed_escaping(bytes: &[u8]) -> impl fmt::Display + use<'_> {
+                // Don't escape if all the characters are likely
+                // to not be a problem when copied to the shell.
+                fmt::from_fn(move |f| {
+                    if !bytes.is_empty()
+                        && bytes.iter().all(|c| {
+                            c.is_ascii_alphanumeric()
+                                || matches!(c, b'_' | b'/' | b'-' | b'=' | b'.' | b',')
+                        })
+                    {
+                        // Unwrap is fine, we've checked above that the bytes only contains ascii.
+                        let ascii = crate::str::from_utf8(bytes).unwrap();
+                        write!(f, "{ascii}")
+                    } else {
+                        write!(f, "\"{}\"", bytes.escape_ascii())
+                    }
+                })
+            }
+
             if let Some(ref cwd) = self.cwd {
-                write!(f, "cd {cwd:?} && ")?;
+                write!(f, "cd {} && ", relaxed_escaping(cwd.to_bytes()))?;
             }
             if self.env.does_clear() {
                 write!(f, "env -i ")?;
@@ -595,23 +616,29 @@ impl fmt::Debug for Command {
                             write!(f, "env ")?;
                             any_removed = true;
                         }
-                        write!(f, "-u {} ", key.to_string_lossy())?;
+                        write!(f, "-u {} ", relaxed_escaping(key.as_encoded_bytes()))?;
                     }
                 }
             }
             // Altered env vars can just be added in front of the program.
             for (key, value_opt) in self.get_envs() {
                 if let Some(value) = value_opt {
-                    write!(f, "{}={value:?} ", key.to_string_lossy())?;
+                    write!(
+                        f,
+                        "{}={} ",
+                        relaxed_escaping(key.as_encoded_bytes()),
+                        relaxed_escaping(value.as_encoded_bytes())
+                    )?;
                 }
             }
             if self.program != self.args[0] {
-                write!(f, "[{:?}] ", self.program)?;
+                write!(f, "[{}] ", relaxed_escaping(self.program.to_bytes()))?;
             }
-            write!(f, "{:?}", self.args[0])?;
+
+            write!(f, "{}", relaxed_escaping(self.args[0].to_bytes()))?;
 
             for arg in &self.args[1..] {
-                write!(f, " {:?}", arg)?;
+                write!(f, " {}", relaxed_escaping(arg.to_bytes()))?;
             }
             Ok(())
         }

library/std/src/sys/pal/unix/process/process_common/tests.rs

@@ -190,3 +190,36 @@ fn unix_exit_statuses() {
         }
     }
 }
+
+#[test]
+fn command_debug_escaping() {
+    #[track_caller]
+    fn check(arg: impl AsRef<OsStr>, expected: &str) {
+        let cmd = Command::new(arg.as_ref());
+        assert_eq!(format!("{cmd:?}"), expected);
+    }
+
+    // Escaped.
+    check("", "\"\"");
+    check("é", "\"\\xc3\\xa9\"");
+    check("a'", "\"a\\'\"");
+    check("a\"", "\"a\\\"\"");
+    check(" ", "\" \"");
+    check(
+        "/Users/The user's name/.cargo/bin/cargo",
+        "\"/Users/The user\\'s name/.cargo/bin/cargo\"",
+    );
+
+    // Simple enough that we don't escape them.
+    check("a", "a");
+    check("/my/simple/path", "/my/simple/path");
+    check("abc-defg_1234", "abc-defg_1234");
+
+    // Real-world use-case, immediately clear that two of the arguments are passed as one.
+    let mut cmd = crate::process::Command::new("ld");
+    cmd.arg("my/file.o");
+    cmd.arg("-macos_version_min");
+    cmd.arg("13.0");
+    cmd.arg("-arch arm64");
+    assert_eq!(format!("{cmd:?}"), "ld my/file.o -macos_version_min 13.0 \"-arch arm64\"");
+}