Add safe wrappers around fs in run_make_support

Author: Oneirical

src/tools/run-make-support/src/fs.rs

@@ -0,0 +1,86 @@
+use std::fs;
+use std::path::Path;
+
+/// A safe wrapper around `std::fs::remove_file` that prints the file path if an operation fails.
+pub fn remove_file<P: AsRef<Path> + std::fmt::Debug>(path: P) {
+    fs::remove_file(path.as_ref())
+        .expect(&format!("The file in path \"{:?}\" could not be removed.", path.as_ref()));
+}
+
+/// A safe wrapper around `std::fs::copy` that prints the file paths if an operation fails.
+pub fn copy<P: AsRef<Path> + std::fmt::Debug, Q: AsRef<Path> + std::fmt::Debug>(from: P, to: Q) {
+    fs::copy(from.as_ref(), to.as_ref()).expect(&format!(
+        "The file \"{:?}\" could not be copied over to \"{:?}\".",
+        from.as_ref(),
+        to.as_ref(),
+    ));
+}
+
+/// A safe wrapper around `std::fs::File::create` that prints the file path if an operation fails.
+pub fn create_file<P: AsRef<Path> + std::fmt::Debug>(path: P) {
+    fs::File::create(path.as_ref())
+        .expect(&format!("The file in path \"{:?}\" could not be created.", path.as_ref()));
+}
+
+/// A safe wrapper around `std::fs::read` that prints the file path if an operation fails.
+pub fn read<P: AsRef<Path> + std::fmt::Debug>(path: P) -> Vec<u8> {
+    fs::read(path.as_ref())
+        .expect(&format!("The file in path \"{:?}\" could not be read.", path.as_ref()))
+}
+
+/// A safe wrapper around `std::fs::read_to_string` that prints the file path if an operation fails.
+pub fn read_to_string<P: AsRef<Path> + std::fmt::Debug>(path: P) -> String {
+    fs::read_to_string(path.as_ref()).expect(&format!(
+        "The file in path \"{:?}\" could not be read into a String.",
+        path.as_ref()
+    ))
+}
+
+/// A safe wrapper around `std::fs::read_dir` that prints the file path if an operation fails.
+pub fn read_dir<P: AsRef<Path> + std::fmt::Debug>(path: P) -> fs::ReadDir {
+    fs::read_dir(path.as_ref())
+        .expect(&format!("The directory in path \"{:?}\" could not be read.", path.as_ref()))
+}
+
+/// A safe wrapper around `std::fs::write` that prints the file path if an operation fails.
+pub fn write<P: AsRef<Path> + std::fmt::Debug, C: AsRef<[u8]>>(path: P, contents: C) {
+    fs::read(path.as_ref(), contents.as_ref())
+        .expect(&format!("The file in path \"{:?}\" could not be written to.", path.as_ref()));
+}
+
+/// A safe wrapper around `std::fs::remove_dir_all` that prints the file path if an operation fails.
+pub fn remove_dir_all<P: AsRef<Path> + std::fmt::Debug>(path: P) {
+    fs::remove_dir_all(path.as_ref()).expect(&format!(
+        "The directory in path \"{:?}\" could not be removed alongside all its contents.",
+        path.as_ref(),
+    ));
+}
+
+/// A safe wrapper around `std::fs::create_dir` that prints the file path if an operation fails.
+pub fn create_dir<P: AsRef<Path> + std::fmt::Debug>(path: P) {
+    fs::create_dir(path.as_ref())
+        .expect(&format!("The directory in path \"{:?}\" could not be created.", path.as_ref()));
+}
+
+/// A safe wrapper around `std::fs::create_dir_all` that prints the file path if an operation fails.
+pub fn create_dir_all<P: AsRef<Path> + std::fmt::Debug>(path: P) {
+    fs::create_dir_all(path.as_ref()).expect(&format!(
+        "The directory (and all its parents) in path \"{:?}\" could not be created.",
+        path.as_ref()
+    ));
+}
+
+/// A safe wrapper around `std::fs::metadata` that prints the file path if an operation fails.
+pub fn metadata<P: AsRef<Path> + std::fmt::Debug>(path: P) -> fs::Metadata {
+    fs::metadata(path.as_ref())
+        .expect(&format!("The file's metadata in path \"{:?}\" could not be read.", path.as_ref()))
+}
+
+/// A safe wrapper around `std::fs::rename` that prints the file paths if an operation fails.
+pub fn rename<P: AsRef<Path> + std::fmt::Debug, Q: AsRef<Path> + std::fmt::Debug>(from: P, to: Q) {
+    fs::rename(from.as_ref(), to.as_ref()).expect(&format!(
+        "The file \"{:?}\" could not be moved over to \"{:?}\".",
+        from.as_ref(),
+        to.as_ref(),
+    ));
+}

src/tools/run-make-support/src/lib.rs

@@ -12,7 +12,6 @@ pub mod rustc;
 pub mod rustdoc;
 
 use std::env;
-use std::fs;
 use std::io;
 use std::path::{Path, PathBuf};
 use std::process::{Command, Output};
@@ -35,10 +34,6 @@ pub fn tmp_dir() -> PathBuf {
     env::var_os("TMPDIR").unwrap().into()
 }
 
-pub fn tmp_path<P: AsRef<Path>>(path: P) -> PathBuf {
-    tmp_dir().join(path.as_ref())
-}
-
 /// `TARGET`
 pub fn target() -> String {
     env::var("TARGET").unwrap()
@@ -62,7 +57,7 @@ pub fn is_darwin() -> bool {
 /// Construct a path to a static library under `$TMPDIR` given the library name. This will return a
 /// path with `$TMPDIR` joined with platform-and-compiler-specific library name.
 pub fn static_lib(name: &str) -> PathBuf {
-    tmp_path(static_lib_name(name))
+    tmp_dir().join(static_lib_name(name))
 }
 
 pub fn python_command() -> Command {
@@ -80,6 +75,28 @@ pub fn source_path() -> PathBuf {
     std::env::var("S").expect("S variable does not exist").into()
 }
 
+/// Creates a new symlink to a path on the filesystem, adjusting for Windows or Unix.
+#[cfg(target_family = "windows")]
+pub fn create_symlink<P: AsRef<Path>, Q: AsRef<Path>>(original: P, link: Q) {
+    use std::os::windows::fs;
+    fs::symlink_file(original.as_ref(), link.as_ref()).expect(&format!(
+        "failed to create symlink {:?} for {:?}",
+        link.as_ref().display(),
+        original.as_ref().display(),
+    ));
+}
+
+/// Creates a new symlink to a path on the filesystem, adjusting for Windows or Unix.
+#[cfg(target_family = "unix")]
+pub fn create_symlink<P: AsRef<Path>, Q: AsRef<Path>>(original: P, link: Q) {
+    use std::os::unix::fs;
+    fs::symlink(original.as_ref(), link.as_ref()).expect(&format!(
+        "failed to create symlink {:?} for {:?}",
+        link.as_ref().display(),
+        original.as_ref().display(),
+    ));
+}
+
 /// Construct the static library name based on the platform.
 pub fn static_lib_name(name: &str) -> String {
     // See tools.mk (irrelevant lines omitted):
@@ -107,7 +124,7 @@ pub fn static_lib_name(name: &str) -> String {
 /// Construct a path to a dynamic library under `$TMPDIR` given the library name. This will return a
 /// path with `$TMPDIR` joined with platform-and-compiler-specific library name.
 pub fn dynamic_lib(name: &str) -> PathBuf {
-    tmp_path(dynamic_lib_name(name))
+    tmp_dir().join(dynamic_lib_name(name))
 }
 
 /// Construct the dynamic library name based on the platform.
@@ -139,7 +156,7 @@ pub fn dynamic_lib_name(name: &str) -> String {
 /// Construct a path to a rust library (rlib) under `$TMPDIR` given the library name. This will return a
 /// path with `$TMPDIR` joined with the library name.
 pub fn rust_lib(name: &str) -> PathBuf {
-    tmp_path(format!("lib{name}.rlib"))
+    tmp_dir().join(format!("lib{name}.rlib"))
 }
 
 /// Construct the binary name based on platform.
@@ -212,15 +229,15 @@ pub fn copy_dir_all(src: impl AsRef<Path>, dst: impl AsRef<Path>) {
     fn copy_dir_all_inner(src: impl AsRef<Path>, dst: impl AsRef<Path>) -> io::Result<()> {
         let dst = dst.as_ref();
         if !dst.is_dir() {
-            fs::create_dir_all(&dst)?;
+            std::fs::create_dir_all(&dst)?;
         }
-        for entry in fs::read_dir(src)? {
+        for entry in std::fs::read_dir(src)? {
             let entry = entry?;
             let ty = entry.file_type()?;
             if ty.is_dir() {
                 copy_dir_all_inner(entry.path(), dst.join(entry.file_name()))?;
             } else {
-                fs::copy(entry.path(), dst.join(entry.file_name()))?;
+                std::fs::copy(entry.path(), dst.join(entry.file_name()))?;
             }
         }
         Ok(())
@@ -239,15 +256,8 @@ pub fn copy_dir_all(src: impl AsRef<Path>, dst: impl AsRef<Path>) {
 
 /// Check that all files in `dir1` exist and have the same content in `dir2`. Panic otherwise.
 pub fn recursive_diff(dir1: impl AsRef<Path>, dir2: impl AsRef<Path>) {
-    fn read_file(path: &Path) -> Vec<u8> {
-        match fs::read(path) {
-            Ok(c) => c,
-            Err(e) => panic!("Failed to read `{}`: {:?}", path.display(), e),
-        }
-    }
-
     let dir2 = dir2.as_ref();
-    for entry in fs::read_dir(dir1).unwrap() {
+    for entry in fs::read_dir(dir1) {
         let entry = entry.unwrap();
         let entry_name = entry.file_name();
         let path = entry.path();
@@ -256,8 +266,8 @@ pub fn recursive_diff(dir1: impl AsRef<Path>, dir2: impl AsRef<Path>) {
             recursive_diff(&path, &dir2.join(entry_name));
         } else {
             let path2 = dir2.join(entry_name);
-            let file1 = read_file(&path);
-            let file2 = read_file(&path2);
+            let file1 = fs::read(&path);
+            let file2 = fs::read(&path2);
 
             // We don't use `assert_eq!` because they are `Vec<u8>`, so not great for display.
             // Why not using String? Because there might be minified files or even potentially
@@ -272,17 +282,6 @@ pub fn recursive_diff(dir1: impl AsRef<Path>, dir2: impl AsRef<Path>) {
     }
 }
 
-/// Check that `haystack` does not contain `needle`. Panic otherwise.
-pub fn assert_not_contains(haystack: &str, needle: &str) {
-    if haystack.contains(needle) {
-        eprintln!("=== HAYSTACK ===");
-        eprintln!("{}", haystack);
-        eprintln!("=== NEEDLE ===");
-        eprintln!("{}", needle);
-        panic!("needle was unexpectedly found in haystack");
-    }
-}
-
 /// Implement common helpers for command wrappers. This assumes that the command wrapper is a struct
 /// containing a `cmd: Command` field and a `output` function. The provided helpers are:
 ///
@@ -366,7 +365,7 @@ macro_rules! impl_common_helpers {
                 self
             }
 
-            /// Inspect what the underlying [`Command`] is up to the
+            /// Inspect what the underlying [`Command`][::std::process::Command] is up to the
             /// current construction.
             pub fn inspect<I>(&mut self, inspector: I) -> &mut Self
             where

tests/run-make/c-link-to-rust-staticlib/rmake.rs

@@ -3,13 +3,14 @@
 
 //@ ignore-cross-compile
 
+use run_make_support::fs::remove_file;
 use run_make_support::{cc, extra_c_flags, run, rustc, static_lib};
 use std::fs;
 
 fn main() {
     rustc().input("foo.rs").run();
     cc().input("bar.c").input(static_lib("foo")).out_exe("bar").args(&extra_c_flags()).run();
     run("bar");
-    fs::remove_file(static_lib("foo"));
+    remove_file(static_lib("foo"));
     run("bar");
 }

tests/run-make/compiler-builtins/rmake.rs

@@ -14,6 +14,7 @@
 
 #![deny(warnings)]
 
+use run_make_support::fs::{read, read_dir, write};
 use run_make_support::object;
 use run_make_support::object::read::archive::ArchiveFile;
 use run_make_support::object::read::Object;
@@ -41,8 +42,8 @@ fn main() {
 
     // Set up the tiniest Cargo project: An empty no_std library. Just enough to run -Zbuild-std.
     let manifest_path = tmp_path("Cargo.toml");
-    std::fs::write(&manifest_path, MANIFEST.as_bytes()).unwrap();
-    std::fs::write(tmp_path("lib.rs"), b"#![no_std]").unwrap();
+    write(&manifest_path, MANIFEST.as_bytes());
+    write(tmp_path("lib.rs"), b"#![no_std]");
 
     let path = std::env::var("PATH").unwrap();
     let rustc = std::env::var("RUSTC").unwrap();
@@ -71,8 +72,7 @@ fn main() {
     assert!(status.success());
 
     let rlibs_path = target_dir.join(target).join("debug").join("deps");
-    let compiler_builtins_rlib = std::fs::read_dir(rlibs_path)
-        .unwrap()
+    let compiler_builtins_rlib = read_dir(rlibs_path)
         .find_map(|e| {
             let path = e.unwrap().path();
             let file_name = path.file_name().unwrap().to_str().unwrap();
@@ -86,7 +86,7 @@ fn main() {
 
     // rlib files are archives, where the archive members each a CGU, and we also have one called
     // lib.rmeta which is the encoded metadata. Each of the CGUs is an object file.
-    let data = std::fs::read(compiler_builtins_rlib).unwrap();
+    let data = read(compiler_builtins_rlib);
 
     let mut defined_symbols = HashSet::new();
     let mut undefined_relocations = HashSet::new();

tests/run-make/doctests-keep-binaries/rmake.rs

@@ -1,13 +1,13 @@
 // Check that valid binaries are persisted by running them, regardless of whether the
 // --run or --no-run option is used.
 
+use run_make_support::fs::{create_dir, remove_dir_all};
 use run_make_support::{run, rustc, rustdoc, tmp_dir, tmp_path};
-use std::fs::{create_dir, remove_dir_all};
 use std::path::Path;
 
 fn setup_test_env<F: FnOnce(&Path, &Path)>(callback: F) {
     let out_dir = tmp_path("doctests");
-    create_dir(&out_dir).expect("failed to create doctests folder");
+    create_dir(&out_dir);
     rustc().input("t.rs").crate_type("rlib").run();
     callback(&out_dir, &tmp_path("libt.rlib"));
     remove_dir_all(out_dir);
@@ -46,7 +46,7 @@ fn main() {
     setup_test_env(|_out_dir, extern_path| {
         let run_dir = "rundir";
         let run_dir_path = tmp_path("rundir");
-        create_dir(&run_dir_path).expect("failed to create rundir folder");
+        create_dir(&run_dir_path);
 
         rustdoc()
             .current_dir(tmp_dir())

tests/run-make/doctests-runtool/rmake.rs

@@ -1,13 +1,13 @@
 // Tests behavior of rustdoc `--runtool`.
 
+use run_make_support::fs::{create_dir, remove_dir_all};
 use run_make_support::{rustc, rustdoc, tmp_dir, tmp_path};
 use std::env::current_dir;
-use std::fs::{create_dir, remove_dir_all};
 use std::path::PathBuf;
 
 fn mkdir(name: &str) -> PathBuf {
     let dir = tmp_path(name);
-    create_dir(&dir).expect("failed to create doctests folder");
+    create_dir(&dir);
     dir
 }
 

tests/run-make/issue-107495-archive-permissions/rmake.rs

@@ -3,8 +3,8 @@
 #[cfg(unix)]
 extern crate libc;
 
+use run_make_support::fs;
 use run_make_support::{aux_build, tmp_path};
-use std::fs;
 #[cfg(unix)]
 use std::os::unix::fs::PermissionsExt;
 use std::path::Path;

tests/run-make/no-intermediate-extras/rmake.rs

@@ -11,6 +11,7 @@ use std::fs;
 fn main() {
     rustc().crate_type("rlib").arg("--test").input("foo.rs").run();
     assert!(
+        // Do not use run-make-support's fs wrapper here - this needs to return an Error.
         fs::remove_file(tmp_path("foo.bc")).is_err(),
         "An unwanted .bc file was created by run-make/no-intermediate-extras."
     );

tests/run-make/non-unicode-env/rmake.rs

@@ -1,3 +1,4 @@
+use run_make_support::fs;
 use run_make_support::rustc;
 
 fn main() {
@@ -7,6 +8,6 @@ fn main() {
     let non_unicode: std::ffi::OsString = std::os::windows::ffi::OsStringExt::from_wide(&[0xD800]);
     let output = rustc().input("non_unicode_env.rs").env("NON_UNICODE_VAR", non_unicode).run_fail();
     let actual = std::str::from_utf8(&output.stderr).unwrap();
-    let expected = std::fs::read_to_string("non_unicode_env.stderr").unwrap();
+    let expected = fs::read_to_string("non_unicode_env.stderr");
     assert_eq!(actual, expected);
 }

tests/run-make/non-unicode-in-incremental-dir/rmake.rs

@@ -5,6 +5,7 @@ fn main() {
     let non_unicode: &std::ffi::OsStr = std::os::unix::ffi::OsStrExt::from_bytes(&[0xFF]);
     #[cfg(windows)]
     let non_unicode: std::ffi::OsString = std::os::windows::ffi::OsStringExt::from_wide(&[0xD800]);
+    // Do not use run-make-support's fs wrapper, this needs special handling.
     match std::fs::create_dir(tmp_path(&non_unicode)) {
         // If an error occurs, check if creating a directory with a valid Unicode name would
         // succeed.
@@ -17,8 +18,8 @@ fn main() {
     }
     let incr_dir = tmp_path("incr-dir");
     rustc().input("foo.rs").incremental(&incr_dir).run();
-    for crate_dir in std::fs::read_dir(&incr_dir).unwrap() {
-        std::fs::create_dir(crate_dir.unwrap().path().join(&non_unicode)).unwrap();
+    for crate_dir in run_make_support::fs::read_dir(&incr_dir) {
+        run_make_support::fs::create_dir(crate_dir.unwrap().path().join(&non_unicode));
     }
     rustc().input("foo.rs").incremental(&incr_dir).run();
 }

tests/run-make/print-cfg/rmake.rs

@@ -10,6 +10,7 @@ use std::ffi::OsString;
 use std::io::BufRead;
 use std::iter::FromIterator;
 
+use run_make_support::fs;
 use run_make_support::{rustc, tmp_path};
 
 struct PrintCfg {
@@ -97,7 +98,7 @@ fn check(PrintCfg { target, includes, disallow }: PrintCfg) {
 
         let output = rustc().target(target).arg(print_arg).run();
 
-        let output = std::fs::read_to_string(&tmp_path).unwrap();
+        let output = fs::read_to_string(&tmp_path).unwrap();
 
         check_(&output, includes, disallow);
     }