tests: update for renamed `fs` module in run_make_support

tests/run-make/CURRENT_RUSTC_VERSION/rmake.rs

@@ -5,14 +5,14 @@
 
 use std::path::PathBuf;
 
-use run_make_support::{aux_build, fs_wrapper, rustc, source_root};
+use run_make_support::{aux_build, fs as rfs, rustc, source_root};
 
 fn main() {
     aux_build().input("stable.rs").emit("metadata").run();
 
     let output =
         rustc().input("main.rs").emit("metadata").extern_("stable", "libstable.rmeta").run();
-    let version = fs_wrapper::read_to_string(source_root().join("src/version"));
+    let version = rfs::read_to_string(source_root().join("src/version"));
     let expected_string = format!("stable since {}", version.trim());
     output.assert_stderr_contains(expected_string);
 }

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

@@ -3,9 +3,7 @@
 
 //@ ignore-cross-compile
 
-use run_make_support::{
+use run_make_support::{cc, cwd, dynamic_lib_extension, fs as rfs, is_msvc, run, run_fail, rustc};
-    cc, cwd, dynamic_lib_extension, fs_wrapper, is_msvc, read_dir, run, run_fail, rustc,
-};
 
 fn main() {
     rustc().input("foo.rs").run();
@@ -21,14 +19,14 @@ fn main() {
     run("bar");
 
     let expected_extension = dynamic_lib_extension();
-    read_dir(cwd(), |path| {
+    rfs::read_dir_entries(cwd(), |path| {
         if path.is_file()
             && path.extension().is_some_and(|ext| ext == expected_extension)
             && path.file_name().and_then(|name| name.to_str()).is_some_and(|name| {
                 name.ends_with(".so") || name.ends_with(".dll") || name.ends_with(".dylib")
             })
         {
-            fs_wrapper::remove_file(path);
+            rfs::remove_file(path);
         }
     });
     run_fail("bar");

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

@@ -3,7 +3,7 @@
 
 //@ ignore-cross-compile
 
-use run_make_support::fs_wrapper::remove_file;
+use run_make_support::fs::remove_file;
 use run_make_support::{cc, extra_c_flags, run, rustc, static_lib_name};
 use std::fs;
 

tests/run-make/cdylib/rmake.rs

@@ -10,7 +10,7 @@
 
 //@ ignore-cross-compile
 
-use run_make_support::{cc, cwd, dynamic_lib_name, fs_wrapper, is_msvc, run, rustc};
+use run_make_support::{cc, cwd, dynamic_lib_name, fs as rfs, is_msvc, run, rustc};
 
 fn main() {
     rustc().input("bar.rs").run();
@@ -23,7 +23,7 @@ fn main() {
     }
 
     run("foo");
-    fs_wrapper::remove_file(dynamic_lib_name("foo"));
+    rfs::remove_file(dynamic_lib_name("foo"));
 
     rustc().input("foo.rs").arg("-Clto").run();
     run("foo");

tests/run-make/comment-section/rmake.rs

@@ -9,9 +9,10 @@
 
 use std::path::PathBuf;
 
+use run_make_support::fs as rfs;
 use run_make_support::llvm_readobj;
 use run_make_support::rustc;
-use run_make_support::{cwd, env_var, read_dir, run_in_tmpdir};
+use run_make_support::{cwd, env_var, run_in_tmpdir};
 
 fn main() {
     let target = env_var("TARGET");
@@ -33,7 +34,7 @@ fn main() {
 
     // Check all object files (including temporary outputs) have a `.comment`
     // section with the expected content.
-    read_dir(cwd(), |f| {
+    rfs::read_dir_entries(cwd(), |f| {
         if !f.extension().is_some_and(|ext| ext == "o") {
             return;
         }

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

@@ -14,7 +14,7 @@
 
 #![deny(warnings)]
 
-use run_make_support::fs_wrapper::{read, read_dir};
+use run_make_support::fs::{read, read_dir};
 use run_make_support::object::read::archive::ArchiveFile;
 use run_make_support::object::read::Object;
 use run_make_support::object::ObjectSection;

tests/run-make/compiler-lookup-paths/rmake.rs

@@ -9,16 +9,16 @@
 //@ ignore-wasm64
 // Reason: a C compiler is required for build_native_static_lib
 
-use run_make_support::{build_native_static_lib, fs_wrapper, rustc, static_lib_name};
+use run_make_support::{build_native_static_lib, fs as rfs, rustc, static_lib_name};
 
 fn main() {
     build_native_static_lib("native");
     let lib_native = static_lib_name("native");
-    fs_wrapper::create_dir_all("crate");
+    rfs::create_dir_all("crate");
-    fs_wrapper::create_dir_all("native");
+    rfs::create_dir_all("native");
-    fs_wrapper::rename(&lib_native, format!("native/{}", &lib_native));
+    rfs::rename(&lib_native, format!("native/{}", &lib_native));
     rustc().input("a.rs").run();
-    fs_wrapper::rename("liba.rlib", "crate/liba.rlib");
+    rfs::rename("liba.rlib", "crate/liba.rlib");
     rustc().input("b.rs").specific_library_search_path("native", "crate").run_fail();
     rustc().input("b.rs").specific_library_search_path("dependency", "crate").run_fail();
     rustc().input("b.rs").specific_library_search_path("crate", "crate").run();
@@ -35,8 +35,8 @@ fn main() {
     rustc().input("d.rs").specific_library_search_path("all", "native").run();
 
     // Deduplication tests.
-    fs_wrapper::create_dir_all("e1");
+    rfs::create_dir_all("e1");
-    fs_wrapper::create_dir_all("e2");
+    rfs::create_dir_all("e2");
 
     rustc().input("e.rs").output("e1/libe.rlib").run();
     rustc().input("e.rs").output("e2/libe.rlib").run();

tests/run-make/const-prop-lint/rmake.rs

@@ -1,11 +1,11 @@
 // Tests that const prop lints interrupting codegen don't leave `.o` files around.
 
-use run_make_support::{cwd, fs_wrapper, rustc};
+use run_make_support::{cwd, fs as rfs, rustc};
 
 fn main() {
     rustc().input("input.rs").run_fail().assert_exit_code(1);
 
-    for entry in fs_wrapper::read_dir(cwd()) {
+    for entry in rfs::read_dir(cwd()) {
         let entry = entry.unwrap();
         let path = entry.path();
 

tests/run-make/crate-name-priority/rmake.rs

@@ -4,15 +4,15 @@
 // and the compiler flags, and checks that the flag is favoured each time.
 // See https://github.com/rust-lang/rust/pull/15518
 
-use run_make_support::{bin_name, fs_wrapper, rustc};
+use run_make_support::{bin_name, fs as rfs, rustc};
 
 fn main() {
     rustc().input("foo.rs").run();
-    fs_wrapper::remove_file(bin_name("foo"));
+    rfs::remove_file(bin_name("foo"));
     rustc().input("foo.rs").crate_name("bar").run();
-    fs_wrapper::remove_file(bin_name("bar"));
+    rfs::remove_file(bin_name("bar"));
     rustc().input("foo1.rs").run();
-    fs_wrapper::remove_file(bin_name("foo"));
+    rfs::remove_file(bin_name("foo"));
     rustc().input("foo1.rs").output(bin_name("bar1")).run();
-    fs_wrapper::remove_file(bin_name("bar1"));
+    rfs::remove_file(bin_name("bar1"));
 }

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

@@ -1,7 +1,7 @@
 // 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_wrapper::{create_dir, remove_dir_all};
+use run_make_support::fs::{create_dir, remove_dir_all};
 use run_make_support::{run, rustc, rustdoc};
 use std::path::Path;
 

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

@@ -1,6 +1,6 @@
 // Tests behavior of rustdoc `--runtool`.
 
-use run_make_support::fs_wrapper::{create_dir, remove_dir_all};
+use run_make_support::fs::{create_dir, remove_dir_all};
 use run_make_support::{rustc, rustdoc};
 use std::path::PathBuf;
 

tests/run-make/dump-mono-stats/rmake.rs

@@ -4,7 +4,7 @@
 // a specific expected string.
 // See https://github.com/rust-lang/rust/pull/105481
 
-use run_make_support::{cwd, fs_wrapper, rustc};
+use run_make_support::{cwd, fs as rfs, rustc};
 
 fn main() {
     rustc()
@@ -13,5 +13,5 @@ fn main() {
         .arg(format!("-Zdump-mono-stats={}", cwd().display()))
         .arg("-Zdump-mono-stats-format=json")
         .run();
-    assert!(fs_wrapper::read_to_string("foo.mono_items.json").contains(r#""name":"bar""#));
+    assert!(rfs::read_to_string("foo.mono_items.json").contains(r#""name":"bar""#));
 }

tests/run-make/dylib-chain/rmake.rs

@@ -8,7 +8,7 @@
 //@ ignore-cross-compile
 // Reason: the compiled binary is executed
 
-use run_make_support::{dynamic_lib_name, fs_wrapper, run, run_fail, rustc};
+use run_make_support::{dynamic_lib_name, fs as rfs, run, run_fail, rustc};
 
 fn main() {
     rustc().input("m1.rs").arg("-Cprefer-dynamic").run();
@@ -16,8 +16,8 @@ fn main() {
     rustc().input("m3.rs").arg("-Cprefer-dynamic").run();
     rustc().input("m4.rs").run();
     run("m4");
-    fs_wrapper::remove_file(dynamic_lib_name("m1"));
+    rfs::remove_file(dynamic_lib_name("m1"));
-    fs_wrapper::remove_file(dynamic_lib_name("m2"));
+    rfs::remove_file(dynamic_lib_name("m2"));
-    fs_wrapper::remove_file(dynamic_lib_name("m3"));
+    rfs::remove_file(dynamic_lib_name("m3"));
     run_fail("m4");
 }

tests/run-make/emit-named-files/rmake.rs

@@ -1,6 +1,6 @@
 use std::path::Path;
 
-use run_make_support::{fs_wrapper, rustc};
+use run_make_support::{fs as rfs, rustc};
 
 fn emit_and_check(out_dir: &Path, out_file: &str, format: &str) {
     let out_file = out_dir.join(out_file);
@@ -11,7 +11,7 @@ fn emit_and_check(out_dir: &Path, out_file: &str, format: &str) {
 fn main() {
     let out_dir = Path::new("emit");
 
-    fs_wrapper::create_dir(&out_dir);
+    rfs::create_dir(&out_dir);
 
     emit_and_check(&out_dir, "libfoo.s", "asm");
     emit_and_check(&out_dir, "libfoo.bc", "llvm-bc");

tests/run-make/emit-path-unhashed/rmake.rs

@@ -6,13 +6,13 @@
 // adding a new output type (in this test, metadata).
 // See https://github.com/rust-lang/rust/issues/86044
 
-use run_make_support::{diff, fs_wrapper, rustc};
+use run_make_support::{diff, fs as rfs, rustc};
 
 fn main() {
-    fs_wrapper::create_dir("emit");
+    rfs::create_dir("emit");
-    fs_wrapper::create_dir("emit/a");
+    rfs::create_dir("emit/a");
-    fs_wrapper::create_dir("emit/b");
+    rfs::create_dir("emit/b");
-    fs_wrapper::create_dir("emit/c");
+    rfs::create_dir("emit/c");
     // The default output name.
     rustc().emit("link").input("foo.rs").run();
     // The output is named with the output flag.

tests/run-make/extern-flag-pathless/rmake.rs

@@ -8,21 +8,21 @@
 //@ ignore-cross-compile
 // Reason: the compiled binary is executed
 
-use run_make_support::{dynamic_lib_name, fs_wrapper, run, run_fail, rust_lib_name, rustc};
+use run_make_support::{dynamic_lib_name, fs as rfs, run, run_fail, rust_lib_name, rustc};
 
 fn main() {
     rustc().input("bar.rs").crate_type("rlib").crate_type("dylib").arg("-Cprefer-dynamic").run();
 
     // By default, the rlib has priority over the dylib.
     rustc().input("foo.rs").arg("--extern").arg("bar").run();
-    fs_wrapper::rename(dynamic_lib_name("bar"), "bar.tmp");
+    rfs::rename(dynamic_lib_name("bar"), "bar.tmp");
     run("foo");
-    fs_wrapper::rename("bar.tmp", dynamic_lib_name("bar"));
+    rfs::rename("bar.tmp", dynamic_lib_name("bar"));
 
     rustc().input("foo.rs").extern_("bar", rust_lib_name("bar")).arg("--extern").arg("bar").run();
-    fs_wrapper::rename(dynamic_lib_name("bar"), "bar.tmp");
+    rfs::rename(dynamic_lib_name("bar"), "bar.tmp");
     run("foo");
-    fs_wrapper::rename("bar.tmp", dynamic_lib_name("bar"));
+    rfs::rename("bar.tmp", dynamic_lib_name("bar"));
 
     // The first explicit usage of extern overrides the second pathless --extern bar.
     rustc()
@@ -31,13 +31,13 @@ fn main() {
         .arg("--extern")
         .arg("bar")
         .run();
-    fs_wrapper::rename(dynamic_lib_name("bar"), "bar.tmp");
+    rfs::rename(dynamic_lib_name("bar"), "bar.tmp");
     run_fail("foo");
-    fs_wrapper::rename("bar.tmp", dynamic_lib_name("bar"));
+    rfs::rename("bar.tmp", dynamic_lib_name("bar"));
 
     // With prefer-dynamic, execution fails as it refuses to use the rlib.
     rustc().input("foo.rs").arg("--extern").arg("bar").arg("-Cprefer-dynamic").run();
-    fs_wrapper::rename(dynamic_lib_name("bar"), "bar.tmp");
+    rfs::rename(dynamic_lib_name("bar"), "bar.tmp");
     run_fail("foo");
-    fs_wrapper::rename("bar.tmp", dynamic_lib_name("bar"));
+    rfs::rename("bar.tmp", dynamic_lib_name("bar"));
 }

tests/run-make/extra-filename-with-temp-outputs/rmake.rs

@@ -7,7 +7,7 @@
 // See https://github.com/rust-lang/rust/pull/15686
 
 use run_make_support::{
-    bin_name, cwd, fs_wrapper, has_prefix, has_suffix, rustc, shallow_find_files,
+    bin_name, cwd, fs as rfs, has_prefix, has_suffix, rustc, shallow_find_files,
 };
 
 fn main() {
@@ -16,6 +16,6 @@ fn main() {
         has_prefix(path, "foobar.foo") && has_suffix(path, "0.rcgu.o")
     });
     let object_file = object_files.get(0).unwrap();
-    fs_wrapper::remove_file(object_file);
+    rfs::remove_file(object_file);
-    fs_wrapper::remove_file(bin_name("foobar"));
+    rfs::remove_file(bin_name("foobar"));
 }

tests/run-make/ice-dep-cannot-find-dep/rmake.rs

@@ -16,7 +16,7 @@
 //       If we used `rustc` the additional '-L rmake_out' option would allow rustc to
 //       actually find the crate.
 
-use run_make_support::{bare_rustc, fs_wrapper, rust_lib_name, rustc};
+use run_make_support::{bare_rustc, fs as rfs, rust_lib_name, rustc};
 
 fn main() {
     rustc().crate_name("a").crate_type("rlib").input("a.rs").arg("--verbose").run();

tests/run-make/inaccessible-temp-dir/rmake.rs

@@ -24,11 +24,11 @@
 // Reason: `set_readonly` has no effect on directories
 // and does not prevent modification.
 
-use run_make_support::{fs_wrapper, rustc, test_while_readonly};
+use run_make_support::{fs as rfs, rustc, test_while_readonly};
 
 fn main() {
     // Create an inaccessible directory.
-    fs_wrapper::create_dir("inaccessible");
+    rfs::create_dir("inaccessible");
     test_while_readonly("inaccessible", || {
         // Run rustc with `-Z temps-dir` set to a directory *inside* the inaccessible one,
         // so that it can't create `tmp`.

tests/run-make/incr-prev-body-beyond-eof/rmake.rs

@@ -13,14 +13,14 @@
 //@ ignore-nvptx64-nvidia-cuda
 // FIXME: can't find crate for `std`
 
-use run_make_support::fs_wrapper as fs;
+use run_make_support::fs as rfs;
 use run_make_support::rustc;
 
 fn main() {
-    fs::create_dir("src");
+    rfs::create_dir("src");
-    fs::create_dir("incr");
+    rfs::create_dir("incr");
-    fs::copy("a.rs", "src/main.rs");
+    rfs::copy("a.rs", "src/main.rs");
     rustc().incremental("incr").input("src/main.rs").run();
-    fs::copy("b.rs", "src/main.rs");
+    rfs::copy("b.rs", "src/main.rs");
     rustc().incremental("incr").input("src/main.rs").run();
 }

tests/run-make/incr-test-moved-file/rmake.rs

@@ -14,14 +14,14 @@
 //@ ignore-nvptx64-nvidia-cuda
 // FIXME: can't find crate for 'std'
 
-use run_make_support::{fs_wrapper, rust_lib_name, rustc};
+use run_make_support::{fs as rfs, rust_lib_name, rustc};
 
 fn main() {
-    fs_wrapper::create_dir("incr");
+    rfs::create_dir("incr");
-    fs_wrapper::create_dir("src");
+    rfs::create_dir("src");
-    fs_wrapper::create_dir("src/mydir");
+    rfs::create_dir("src/mydir");
-    fs_wrapper::copy("main.rs", "src/main.rs");
+    rfs::copy("main.rs", "src/main.rs");
     rustc().input("src/main.rs").incremental("incr").arg("--test").run();
-    fs_wrapper::rename("src/main.rs", "src/mydir/main.rs");
+    rfs::rename("src/main.rs", "src/mydir/main.rs");
     rustc().input("src/mydir/main.rs").incremental("incr").arg("--test").run();
 }

tests/run-make/incremental-debugger-visualizer/rmake.rs

@@ -2,14 +2,14 @@
 // (in this case, foo.py and foo.natvis) are picked up when compiling incrementally.
 // See https://github.com/rust-lang/rust/pull/111641
 
-use run_make_support::{fs_wrapper, invalid_utf8_contains, invalid_utf8_not_contains, rustc};
+use run_make_support::{fs as rfs, invalid_utf8_contains, invalid_utf8_not_contains, rustc};
 use std::io::Read;
 
 fn main() {
-    fs_wrapper::create_file("foo.py");
+    rfs::create_file("foo.py");
-    fs_wrapper::write("foo.py", "GDB script v1");
+    rfs::write("foo.py", "GDB script v1");
-    fs_wrapper::create_file("foo.natvis");
+    rfs::create_file("foo.natvis");
-    fs_wrapper::write("foo.natvis", "Natvis v1");
+    rfs::write("foo.natvis", "Natvis v1");
     rustc()
         .input("foo.rs")
         .crate_type("rlib")
@@ -22,9 +22,9 @@ fn main() {
     invalid_utf8_contains("libfoo.rmeta", "Natvis v1");
 
     // Change only the GDB script and check that the change has been picked up
-    fs_wrapper::remove_file("foo.py");
+    rfs::remove_file("foo.py");
-    fs_wrapper::create_file("foo.py");
+    rfs::create_file("foo.py");
-    fs_wrapper::write("foo.py", "GDB script v2");
+    rfs::write("foo.py", "GDB script v2");
     rustc()
         .input("foo.rs")
         .crate_type("rlib")
@@ -38,9 +38,9 @@ fn main() {
     invalid_utf8_contains("libfoo.rmeta", "Natvis v1");
 
     // Now change the Natvis version and check that the change has been picked up
-    fs_wrapper::remove_file("foo.natvis");
+    rfs::remove_file("foo.natvis");
-    fs_wrapper::create_file("foo.natvis");
+    rfs::create_file("foo.natvis");
-    fs_wrapper::write("foo.natvis", "Natvis v2");
+    rfs::write("foo.natvis", "Natvis v2");
     rustc()
         .input("foo.rs")
         .crate_type("rlib")

tests/run-make/incremental-session-fail/rmake.rs

@@ -4,10 +4,10 @@
 // the ensuing compilation failure is not an ICE.
 // See https://github.com/rust-lang/rust/pull/85698
 
-use run_make_support::{fs_wrapper, rustc};
+use run_make_support::{fs as rfs, rustc};
 
 fn main() {
-    fs_wrapper::create_file("session");
+    rfs::create_file("session");
     // rustc should fail to create the session directory here.
     let out = rustc().input("foo.rs").crate_type("rlib").incremental("session").run_fail();
     out.assert_stderr_contains("could not create incremental compilation crate directory");

tests/run-make/inline-always-many-cgu/rmake.rs

@@ -1,6 +1,6 @@
-use run_make_support::fs_wrapper::read_to_string;
+use run_make_support::fs as rfs;
 use run_make_support::regex::Regex;
-use run_make_support::{read_dir, rustc};
+use run_make_support::rustc;
 
 use std::ffi::OsStr;
 
@@ -8,9 +8,9 @@ fn main() {
     rustc().input("foo.rs").emit("llvm-ir").codegen_units(2).run();
     let re = Regex::new(r"\bcall\b").unwrap();
     let mut nb_ll = 0;
-    read_dir(".", |path| {
+    rfs::read_dir_entries(".", |path| {
         if path.is_file() && path.extension().is_some_and(|ext| ext == OsStr::new("ll")) {
-            assert!(!re.is_match(&read_to_string(path)));
+            assert!(!re.is_match(&rfs::read_to_string(path)));
             nb_ll += 1;
         }
     });

tests/run-make/intrinsic-unreachable/rmake.rs

@@ -8,13 +8,13 @@
 //@ ignore-windows
 // Reason: Because of Windows exception handling, the code is not necessarily any shorter.
 
-use run_make_support::{fs_wrapper, rustc};
+use run_make_support::{fs as rfs, rustc};
 
 fn main() {
     rustc().opt().emit("asm").input("exit-ret.rs").run();
     rustc().opt().emit("asm").input("exit-unreachable.rs").run();
     assert!(
-        fs_wrapper::read_to_string("exit-unreachable.s").lines().count()
+        rfs::read_to_string("exit-unreachable.s").lines().count()
-            < fs_wrapper::read_to_string("exit-ret.s").lines().count()
+            < rfs::read_to_string("exit-ret.s").lines().count()
     );
 }

tests/run-make/invalid-library/rmake.rs

@@ -4,11 +4,11 @@
 // one appearing in stderr in this scenario.
 // See https://github.com/rust-lang/rust/pull/12645
 
-use run_make_support::fs_wrapper::create_file;
+use run_make_support::fs as rfs;
 use run_make_support::{llvm_ar, rustc};
 
 fn main() {
-    create_file("lib.rmeta");
+    rfs::create_file("lib.rmeta");
     llvm_ar().obj_to_ar().output_input("libfoo-ffffffff-1.0.rlib", "lib.rmeta").run();
     rustc().input("foo.rs").run_fail().assert_stderr_contains("found invalid metadata");
 }

tests/run-make/invalid-so/rmake.rs

@@ -4,10 +4,10 @@
 // explains that the file exists, but that its metadata is incorrect.
 // See https://github.com/rust-lang/rust/pull/88368
 
-use run_make_support::{dynamic_lib_name, fs_wrapper, rustc};
+use run_make_support::{dynamic_lib_name, fs as rfs, rustc};
 
 fn main() {
-    fs_wrapper::create_file(dynamic_lib_name("foo"));
+    rfs::create_file(dynamic_lib_name("foo"));
     rustc()
         .crate_type("lib")
         .extern_("foo", dynamic_lib_name("foo"))

tests/run-make/invalid-staticlib/rmake.rs

@@ -4,10 +4,10 @@
 // an internal compiler error (ICE).
 // See https://github.com/rust-lang/rust/pull/28673
 
-use run_make_support::{fs_wrapper, rustc, static_lib_name};
+use run_make_support::{fs as rfs, rustc, static_lib_name};
 
 fn main() {
-    fs_wrapper::create_file(static_lib_name("foo"));
+    rfs::create_file(static_lib_name("foo"));
     rustc()
         .arg("-")
         .crate_type("rlib")

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

@@ -3,7 +3,7 @@
 #[cfg(unix)]
 extern crate libc;
 
-use run_make_support::{aux_build, fs_wrapper};
+use run_make_support::{aux_build, fs as rfs};
 
 #[cfg(unix)]
 use std::os::unix::fs::PermissionsExt;
@@ -20,7 +20,7 @@ fn main() {
 }
 
 fn verify(path: &Path) {
-    let perm = fs_wrapper::metadata(path).permissions();
+    let perm = rfs::metadata(path).permissions();
 
     assert!(!perm.readonly());
 

tests/run-make/ls-metadata/rmake.rs

@@ -6,12 +6,12 @@
 
 //@ ignore-cross-compile
 
-use run_make_support::fs_wrapper;
+use run_make_support::fs as rfs;
 use run_make_support::rustc;
 
 fn main() {
     rustc().input("foo.rs").run();
     rustc().arg("-Zls=root").input("foo").run();
-    fs_wrapper::create_file("bar");
+    rfs::create_file("bar");
     rustc().arg("-Zls=root").input("bar").run();
 }

tests/run-make/lto-readonly-lib/rmake.rs

@@ -7,7 +7,7 @@
 
 //@ ignore-cross-compile
 
-use run_make_support::fs_wrapper;
+use run_make_support::fs as rfs;
 use run_make_support::{run, rust_lib_name, rustc, test_while_readonly};
 
 fn main() {

tests/run-make/many-crates-but-no-match/rmake.rs

@@ -4,12 +4,12 @@
 // what should be done to fix the issue.
 // See https://github.com/rust-lang/rust/issues/13266
 
-use run_make_support::{fs_wrapper, rustc};
+use run_make_support::{fs as rfs, rustc};
 
 fn main() {
-    fs_wrapper::create_dir("a1");
+    rfs::create_dir("a1");
-    fs_wrapper::create_dir("a2");
+    rfs::create_dir("a2");
-    fs_wrapper::create_dir("a3");
+    rfs::create_dir("a3");
     rustc().crate_type("rlib").out_dir("a1").input("crateA1.rs").run();
     rustc().crate_type("rlib").library_search_path("a1").input("crateB.rs").run();
     rustc().crate_type("rlib").out_dir("a2").input("crateA2.rs").run();

tests/run-make/mixing-libs/rmake.rs

@@ -6,7 +6,7 @@
 
 //@ ignore-cross-compile
 
-use run_make_support::{dynamic_lib_name, fs_wrapper, rustc};
+use run_make_support::{dynamic_lib_name, fs as rfs, rustc};
 
 fn main() {
     rustc().input("rlib.rs").crate_type("rlib").crate_type("dylib").run();
@@ -16,6 +16,6 @@ fn main() {
 
     // librlib's dynamic version needs to be removed here to prevent prog.rs from fetching
     // the wrong one.
-    fs_wrapper::remove_file(dynamic_lib_name("rlib"));
+    rfs::remove_file(dynamic_lib_name("rlib"));
     rustc().input("prog.rs").run_fail();
 }

tests/run-make/moved-src-dir-fingerprint-ice/rmake.rs

@@ -17,20 +17,20 @@
 //@ ignore-nvptx64-nvidia-cuda
 // FIXME: can't find crate for 'std'
 
-use run_make_support::{fs_wrapper, rust_lib_name, rustc};
+use run_make_support::{fs as rfs, rust_lib_name, rustc};
 
 fn main() {
-    fs_wrapper::create_dir("incr");
+    rfs::create_dir("incr");
-    fs_wrapper::create_dir("first_src");
+    rfs::create_dir("first_src");
-    fs_wrapper::create_dir("output");
+    rfs::create_dir("output");
-    fs_wrapper::rename("my_lib.rs", "first_src/my_lib.rs");
+    rfs::rename("my_lib.rs", "first_src/my_lib.rs");
-    fs_wrapper::rename("main.rs", "first_src/main.rs");
+    rfs::rename("main.rs", "first_src/main.rs");
     // Build from "first_src"
     std::env::set_current_dir("first_src").unwrap();
     rustc().input("my_lib.rs").incremental("incr").crate_type("lib").run();
     rustc().input("main.rs").incremental("incr").extern_("my_lib", rust_lib_name("my_lib")).run();
     std::env::set_current_dir("..").unwrap();
-    fs_wrapper::rename("first_src", "second_src");
+    rfs::rename("first_src", "second_src");
     std::env::set_current_dir("second_src").unwrap();
     // Build from "second_src" - the output and incremental directory remain identical
     rustc().input("my_lib.rs").incremental("incr").crate_type("lib").run();

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

@@ -1,4 +1,4 @@
-use run_make_support::fs_wrapper;
+use run_make_support::fs as rfs;
 use run_make_support::rustc;
 
 fn main() {
@@ -7,6 +7,6 @@ fn main() {
     #[cfg(windows)]
     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 expected = fs_wrapper::read_to_string("non_unicode_env.stderr");
+    let expected = rfs::read_to_string("non_unicode_env.stderr");
     output.assert_stderr_equals(expected);
 }

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

@@ -1,4 +1,4 @@
-use run_make_support::{fs_wrapper, rustc};
+use run_make_support::{fs as rfs, rustc};
 
 fn main() {
     #[cfg(unix)]
@@ -17,8 +17,8 @@ fn main() {
     }
     let incr_dir = "incr-dir";
     rustc().input("foo.rs").incremental(&incr_dir).run();
-    for crate_dir in fs_wrapper::read_dir(&incr_dir) {
+    for crate_dir in rfs::read_dir(&incr_dir) {
-        fs_wrapper::create_dir(crate_dir.unwrap().path().join(&non_unicode));
+        rfs::create_dir(crate_dir.unwrap().path().join(&non_unicode));
     }
     rustc().input("foo.rs").incremental(&incr_dir).run();
 }

tests/run-make/obey-crate-type-flag/rmake.rs

@@ -6,7 +6,7 @@
 //@ ignore-cross-compile
 
 use run_make_support::{
-    cwd, dynamic_lib_name, fs_wrapper, has_extension, rust_lib_name, rustc, shallow_find_files,
+    cwd, dynamic_lib_name, fs as rfs, has_extension, rust_lib_name, rustc, shallow_find_files,
 };
 use std::path::Path;
 
@@ -15,7 +15,7 @@ fn main() {
     assert!(Path::new(&dynamic_lib_name("test")).exists());
     assert!(Path::new(&rust_lib_name("test")).exists());
 
-    fs_wrapper::remove_file(rust_lib_name("test"));
+    rfs::remove_file(rust_lib_name("test"));
     rustc().crate_type("dylib").input("test.rs").run();
     assert!(shallow_find_files(cwd(), |path| { has_extension(path, "rlib") }).is_empty());
 }

tests/run-make/output-filename-conflicts-with-directory/rmake.rs

@@ -4,10 +4,10 @@
 // potentially-confusing linker error.
 // See https://github.com/rust-lang/rust/pull/47203
 
-use run_make_support::{fs_wrapper, rustc};
+use run_make_support::{fs as rfs, rustc};
 
 fn main() {
-    fs_wrapper::create_dir("foo");
+    rfs::create_dir("foo");
     rustc().input("foo.rs").output("foo").run_fail().assert_stderr_contains(
         r#"the generated executable for the input file "foo.rs" conflicts with the existing directory "foo""#,
     );

tests/run-make/output-filename-overwrites-input/rmake.rs

@@ -4,14 +4,14 @@
 
 //@ ignore-cross-compile
 
-use run_make_support::{fs_wrapper, rustc};
+use run_make_support::{fs as rfs, rustc};
 
 fn main() {
-    fs_wrapper::copy("foo.rs", "foo");
+    rfs::copy("foo.rs", "foo");
     rustc().input("foo").output("foo").run_fail().assert_stderr_contains(
         r#"the input file "foo" would be overwritten by the generated executable"#,
     );
-    fs_wrapper::copy("bar.rs", "bar.rlib");
+    rfs::copy("bar.rs", "bar.rlib");
     rustc().input("bar.rlib").output("bar.rlib").run_fail().assert_stderr_contains(
         r#"the input file "bar.rlib" would be overwritten by the generated executable"#,
     );

tests/run-make/output-type-permutations/rmake.rs

@@ -5,7 +5,7 @@
 // See https://github.com/rust-lang/rust/pull/12020
 
 use run_make_support::{
-    bin_name, dynamic_lib_name, filename_not_in_denylist, fs_wrapper, rust_lib_name, rustc,
+    bin_name, dynamic_lib_name, filename_not_in_denylist, fs as rfs, rust_lib_name, rustc,
     shallow_find_files, static_lib_name,
 };
 use std::path::PathBuf;
@@ -20,10 +20,10 @@ fn assert_expected_output_files(expectations: Expectations, rustc_invocation: im
     let Expectations { expected_files: must_exist, allowed_files: can_exist, test_dir: dir } =
         expectations;
 
-    fs_wrapper::create_dir(&dir);
+    rfs::create_dir(&dir);
     rustc_invocation();
     for file in must_exist {
-        fs_wrapper::remove_file(PathBuf::from(&dir).join(&file));
+        rfs::remove_file(PathBuf::from(&dir).join(&file));
     }
     let actual_output_files =
         shallow_find_files(dir, |path| filename_not_in_denylist(path, &can_exist));
@@ -526,17 +526,14 @@ fn main() {
             test_dir: "rlib-emits".to_string(),
         },
         || {
-            fs_wrapper::rename("staticlib-all3/bar.bc", "rlib-emits/foo.bc");
+            rfs::rename("staticlib-all3/bar.bc", "rlib-emits/foo.bc");
             rustc()
                 .input("foo.rs")
                 .emit("llvm-bc,link")
                 .crate_type("rlib")
                 .out_dir("rlib-emits")
                 .run();
-            assert_eq!(
+            assert_eq!(rfs::read("rlib-emits/foo.bc"), rfs::read("rlib-emits/bar.bc"));
-                fs_wrapper::read("rlib-emits/foo.bc"),
-                fs_wrapper::read("rlib-emits/bar.bc")
-            );
         },
     );
 }

tests/run-make/parallel-rustc-no-overwrite/rmake.rs

@@ -5,12 +5,12 @@
 // conflicts. This test uses this flag and checks for successful compilation.
 // See https://github.com/rust-lang/rust/pull/83846
 
-use run_make_support::{fs_wrapper, rustc};
+use run_make_support::{fs as rfs, rustc};
 use std::sync::{Arc, Barrier};
 use std::thread;
 
 fn main() {
-    fs_wrapper::create_file("lib.rs");
+    rfs::create_file("lib.rs");
     let barrier = Arc::new(Barrier::new(2));
     let handle = {
         let barrier = Arc::clone(&barrier);

tests/run-make/pgo-branch-weights/rmake.rs

@@ -10,14 +10,14 @@
 //@ needs-profiler-support
 //@ ignore-cross-compile
 
-use run_make_support::{fs_wrapper, llvm_filecheck, llvm_profdata, run_with_args, rustc};
+use run_make_support::{fs as rfs, llvm_filecheck, llvm_profdata, run_with_args, rustc};
 use std::path::Path;
 
 fn main() {
     let path_prof_data_dir = Path::new("prof_data_dir");
     let path_merged_profdata = path_prof_data_dir.join("merged.profdata");
     rustc().input("opaque.rs").run();
-    fs_wrapper::create_dir_all(&path_prof_data_dir);
+    rfs::create_dir_all(&path_prof_data_dir);
     rustc()
         .input("interesting.rs")
         .profile_generate(&path_prof_data_dir)
@@ -34,8 +34,5 @@ fn main() {
         .codegen_units(1)
         .emit("llvm-ir")
         .run();
-    llvm_filecheck()
+    llvm_filecheck().patterns("filecheck-patterns.txt").stdin(rfs::read("interesting.ll")).run();
-        .patterns("filecheck-patterns.txt")
-        .stdin(fs_wrapper::read("interesting.ll"))
-        .run();
 }

tests/run-make/pgo-use/rmake.rs

@@ -9,8 +9,8 @@
 //@ ignore-cross-compile
 
 use run_make_support::{
-    cwd, fs_wrapper, has_extension, has_prefix, llvm_filecheck, llvm_profdata, run_with_args,
+    cwd, fs as rfs, has_extension, has_prefix, llvm_filecheck, llvm_profdata, run_with_args, rustc,
-    rustc, shallow_find_files,
+    shallow_find_files,
 };
 
 fn main() {
@@ -47,7 +47,7 @@ fn main() {
     // line with the function name before the line with the function attributes.
     // FileCheck only supports checking that something matches on the next line,
     // but not if something matches on the previous line.
-    let ir = fs_wrapper::read_to_string("main.ll");
+    let ir = rfs::read_to_string("main.ll");
     let lines: Vec<_> = ir.lines().rev().collect();
     let mut reversed_ir = lines.join("\n");
     reversed_ir.push('\n');

tests/run-make/prefer-dylib/rmake.rs

@@ -1,6 +1,6 @@
 //@ ignore-cross-compile
 
-use run_make_support::{cwd, dynamic_lib_name, fs_wrapper, read_dir, run, run_fail, rustc};
+use run_make_support::{dynamic_lib_name, fs as rfs, run, run_fail, rustc};
 
 fn main() {
     rustc().input("bar.rs").crate_type("dylib").crate_type("rlib").arg("-Cprefer-dynamic").run();
@@ -8,7 +8,7 @@ fn main() {
 
     run("foo");
 
-    fs_wrapper::remove_file(dynamic_lib_name("bar"));
+    rfs::remove_file(dynamic_lib_name("bar"));
     // This time the command should fail.
     run_fail("foo");
 }

tests/run-make/prefer-rlib/rmake.rs

@@ -3,13 +3,13 @@
 
 //@ ignore-cross-compile
 
-use run_make_support::{dynamic_lib_name, fs_wrapper, path, run, rust_lib_name, rustc};
+use run_make_support::{dynamic_lib_name, fs as rfs, path, run, rust_lib_name, rustc};
 
 fn main() {
     rustc().input("bar.rs").crate_type("dylib").crate_type("rlib").run();
     assert!(path(rust_lib_name("bar")).exists());
     rustc().input("foo.rs").run();
-    fs_wrapper::remove_file(rust_lib_name("bar"));
+    rfs::remove_file(rust_lib_name("bar"));
-    fs_wrapper::remove_file(dynamic_lib_name("bar"));
+    rfs::remove_file(dynamic_lib_name("bar"));
     run("foo");
 }

tests/run-make/pretty-print-with-dep-file/rmake.rs

@@ -5,13 +5,13 @@
 // does not get an unexpected dep-info file.
 // See https://github.com/rust-lang/rust/issues/112898
 
-use run_make_support::{fs_wrapper, invalid_utf8_contains, rustc};
+use run_make_support::{fs as rfs, invalid_utf8_contains, rustc};
 use std::path::Path;
 
 fn main() {
     rustc().emit("dep-info").arg("-Zunpretty=expanded").input("with-dep.rs").run();
     invalid_utf8_contains("with-dep.d", "with-dep.rs");
-    fs_wrapper::remove_file("with-dep.d");
+    rfs::remove_file("with-dep.d");
     rustc().emit("dep-info").arg("-Zunpretty=normal").input("with-dep.rs").run();
     assert!(!Path::new("with-dep.d").exists());
 }

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

@@ -10,7 +10,7 @@ use std::ffi::OsString;
 use std::iter::FromIterator;
 use std::path::PathBuf;
 
-use run_make_support::{fs_wrapper, rustc};
+use run_make_support::{fs as rfs, rustc};
 
 struct PrintCfg {
     target: &'static str,
@@ -96,7 +96,7 @@ fn check(PrintCfg { target, includes, disallow }: PrintCfg) {
 
         rustc().target(target).arg(print_arg).run();
 
-        let output = fs_wrapper::read_to_string(&tmp_path);
+        let output = rfs::read_to_string(&tmp_path);
 
         check_(&output, includes, disallow);
     }

tests/run-make/print-to-output/rmake.rs

@@ -4,7 +4,7 @@
 use std::ffi::OsString;
 use std::path::PathBuf;
 
-use run_make_support::{fs_wrapper, rustc, target};
+use run_make_support::{fs as rfs, rustc, target};
 
 struct Option<'a> {
     target: &'a str,
@@ -49,7 +49,7 @@ fn check(args: Option) {
 
         rustc().target(args.target).arg(print_arg).run();
 
-        fs_wrapper::read_to_string(&tmp_path)
+        rfs::read_to_string(&tmp_path)
     };
 
     check_(&stdout, args.includes);

tests/run-make/remap-path-prefix/rmake.rs

@@ -4,7 +4,7 @@
 // See https://github.com/rust-lang/rust/pull/85344
 
 use run_make_support::bstr::ByteSlice;
-use run_make_support::{bstr, fs_wrapper, is_darwin, rustc};
+use run_make_support::{bstr, fs as rfs, is_darwin, rustc};
 
 fn main() {
     let mut out_simple = rustc();
@@ -60,12 +60,9 @@ fn main() {
 // helper functions.
 fn rmeta_contains(expected: &str) {
     // Normalize to account for path differences in Windows.
-    if !bstr::BString::from(fs_wrapper::read("liblib.rmeta"))
+    if !bstr::BString::from(rfs::read("liblib.rmeta")).replace(b"\\", b"/").contains_str(expected) {
-        .replace(b"\\", b"/")
-        .contains_str(expected)
-    {
         eprintln!("=== FILE CONTENTS (LOSSY) ===");
-        eprintln!("{}", String::from_utf8_lossy(&fs_wrapper::read("liblib.rmeta")));
+        eprintln!("{}", String::from_utf8_lossy(&rfs::read("liblib.rmeta")));
         eprintln!("=== SPECIFIED TEXT ===");
         eprintln!("{}", expected);
         panic!("specified text was not found in file");
@@ -74,12 +71,9 @@ fn rmeta_contains(expected: &str) {
 
 fn rmeta_not_contains(expected: &str) {
     // Normalize to account for path differences in Windows.
-    if bstr::BString::from(fs_wrapper::read("liblib.rmeta"))
+    if bstr::BString::from(rfs::read("liblib.rmeta")).replace(b"\\", b"/").contains_str(expected) {
-        .replace(b"\\", b"/")
-        .contains_str(expected)
-    {
         eprintln!("=== FILE CONTENTS (LOSSY) ===");
-        eprintln!("{}", String::from_utf8_lossy(&fs_wrapper::read("liblib.rmeta")));
+        eprintln!("{}", String::from_utf8_lossy(&rfs::read("liblib.rmeta")));
         eprintln!("=== SPECIFIED TEXT ===");
         eprintln!("{}", expected);
         panic!("specified text was not found in file");

tests/run-make/repr128-dwarf/rmake.rs

@@ -3,7 +3,7 @@
 
 use gimli::{AttributeValue, EndianRcSlice, Reader, RunTimeEndian};
 use object::{Object, ObjectSection};
-use run_make_support::{fs_wrapper, gimli, object, rustc};
+use run_make_support::{fs as rfs, gimli, object, rustc};
 use std::collections::HashMap;
 use std::path::PathBuf;
 use std::rc::Rc;
@@ -19,7 +19,7 @@ fn main() {
         .join("DWARF")
         .join("repr128");
     let output =
-        fs_wrapper::read(if dsym_location.try_exists().unwrap() { dsym_location } else { output });
+        rfs::read(if dsym_location.try_exists().unwrap() { dsym_location } else { output });
     let obj = object::File::parse(output.as_slice()).unwrap();
     let endian = if obj.is_little_endian() { RunTimeEndian::Little } else { RunTimeEndian::Big };
     let dwarf = gimli::Dwarf::load(|section| -> Result<_, ()> {

tests/run-make/reset-codegen-1/rmake.rs

@@ -7,7 +7,7 @@
 
 //@ ignore-cross-compile
 
-use run_make_support::{bin_name, fs_wrapper, rustc};
+use run_make_support::{bin_name, fs as rfs, rustc};
 use std::path::Path;
 
 fn compile(output_file: &str, emit: Option<&str>) {

tests/run-make/resolve-rename/rmake.rs

@@ -5,12 +5,12 @@
 // the renamed library.
 // See https://github.com/rust-lang/rust/pull/49253
 
-use run_make_support::fs_wrapper;
+use run_make_support::fs as rfs;
 use run_make_support::rustc;
 
 fn main() {
     rustc().extra_filename("-hash").input("foo.rs").run();
     rustc().input("bar.rs").run();
-    fs_wrapper::rename("libfoo-hash.rlib", "libfoo-another-hash.rlib");
+    rfs::rename("libfoo-hash.rlib", "libfoo-another-hash.rlib");
     rustc().input("baz.rs").run();
 }

tests/run-make/rlib-chain/rmake.rs

@@ -8,7 +8,7 @@
 //@ ignore-cross-compile
 // Reason: the compiled binary is executed
 
-use run_make_support::{fs_wrapper, run, rust_lib_name, rustc};
+use run_make_support::{fs as rfs, run, rust_lib_name, rustc};
 
 fn main() {
     rustc().input("m1.rs").run();
@@ -16,8 +16,8 @@ fn main() {
     rustc().input("m3.rs").run();
     rustc().input("m4.rs").run();
     run("m4");
-    fs_wrapper::remove_file(rust_lib_name("m1"));
+    rfs::remove_file(rust_lib_name("m1"));
-    fs_wrapper::remove_file(rust_lib_name("m2"));
+    rfs::remove_file(rust_lib_name("m2"));
-    fs_wrapper::remove_file(rust_lib_name("m3"));
+    rfs::remove_file(rust_lib_name("m3"));
     run("m4");
 }

tests/run-make/rustdoc-scrape-examples-remap/scrape.rs

@@ -1,10 +1,10 @@
-use run_make_support::{fs_wrapper, htmldocck, rustc, rustdoc, source_root};
+use run_make_support::{fs as rfs, htmldocck, rustc, rustdoc, source_root};
 use std::path::Path;
 
 pub fn scrape(extra_args: &[&str]) {
     let out_dir = Path::new("rustdoc");
     let crate_name = "foobar";
-    let deps = fs_wrapper::read_dir("examples")
+    let deps = rfs::read_dir("examples")
         .filter_map(|entry| entry.ok().map(|e| e.path()))
         .filter(|path| path.is_file() && path.extension().is_some_and(|ext| ext == "rs"))
         .collect::<Vec<_>>();

tests/run-make/rustdoc-test-args/rmake.rs

@@ -1,10 +1,10 @@
-use run_make_support::{fs_wrapper, rustdoc};
+use run_make_support::{fs as rfs, rustdoc};
 use std::iter;
 use std::path::Path;
 
 fn generate_a_lot_of_cfgs(path: &Path) {
     let content = iter::repeat("--cfg=a\n").take(100_000).collect::<String>();
-    fs_wrapper::write(path, content.as_bytes());
+    rfs::write(path, content.as_bytes());
 }
 
 fn main() {

tests/run-make/rustdoc-themes/rmake.rs

@@ -1,15 +1,14 @@
 // Test that rustdoc will properly load in a theme file and display it in the theme selector.
 
-use run_make_support::{fs_wrapper, htmldocck, rustdoc, source_root};
+use run_make_support::{fs as rfs, htmldocck, rustdoc, source_root};
 use std::path::Path;
 
 fn main() {
     let out_dir = Path::new("rustdoc-themes");
     let test_css = "test.css";
 
-    let no_script = fs_wrapper::read_to_string(
+    let no_script =
-        source_root().join("src/librustdoc/html/static/css/noscript.css"),
+        rfs::read_to_string(source_root().join("src/librustdoc/html/static/css/noscript.css"));
-    );
 
     let mut test_content = String::new();
     let mut found_begin_light = false;
@@ -24,8 +23,8 @@ fn main() {
         }
     }
     assert!(!test_content.is_empty());
-    fs_wrapper::create_dir_all(&out_dir);
+    rfs::create_dir_all(&out_dir);
-    fs_wrapper::write(&test_css, test_content);
+    rfs::write(&test_css, test_content);
 
     rustdoc().output(&out_dir).input("foo.rs").arg("--theme").arg(&test_css).run();
     htmldocck().arg(out_dir).arg("foo.rs").run();

tests/run-make/rustdoc-verify-output-files/rmake.rs

@@ -1,7 +1,7 @@
-use run_make_support::fs_wrapper::copy;
+use run_make_support::fs as rfs;
 use std::path::{Path, PathBuf};
 
-use run_make_support::{assert_recursive_eq, copy_dir_all, rustdoc};
+use run_make_support::{assert_recursive_eq, rustdoc};
 
 #[derive(PartialEq)]
 enum JsonOutput {
@@ -26,7 +26,7 @@ fn main() {
     generate_docs(&out_dir, JsonOutput::No);
 
     // Copy first output for to check if it's exactly same after second compilation.
-    copy_dir_all(&out_dir, &tmp_out_dir);
+    rfs::copy_dir_all(&out_dir, &tmp_out_dir);
 
     // Generate html docs once again on same output.
     generate_docs(&out_dir, JsonOutput::No);
@@ -38,7 +38,7 @@ fn main() {
     assert!(out_dir.join("foobar.json").is_file());
 
     // Copy first json output to check if it's exactly same after second compilation.
-    copy(out_dir.join("foobar.json"), tmp_out_dir.join("foobar.json"));
+    rfs::copy(out_dir.join("foobar.json"), tmp_out_dir.join("foobar.json"));
 
     // Generate json doc on the same output.
     generate_docs(&out_dir, JsonOutput::Yes);

tests/run-make/sepcomp-cci-copies/rmake.rs

@@ -5,7 +5,7 @@
 // See https://github.com/rust-lang/rust/pull/16367
 
 use run_make_support::{
-    count_regex_matches_in_files_with_extension, cwd, fs_wrapper, has_extension, regex, rustc,
+    count_regex_matches_in_files_with_extension, cwd, fs as rfs, has_extension, regex, rustc,
     shallow_find_files,
 };
 

tests/run-make/sepcomp-inlining/rmake.rs

@@ -6,7 +6,7 @@
 // See https://github.com/rust-lang/rust/pull/16367
 
 use run_make_support::{
-    count_regex_matches_in_files_with_extension, cwd, fs_wrapper, has_extension, regex, rustc,
+    count_regex_matches_in_files_with_extension, cwd, fs as rfs, has_extension, regex, rustc,
     shallow_find_files,
 };
 

tests/run-make/sepcomp-separate/rmake.rs

@@ -4,7 +4,7 @@
 // See https://github.com/rust-lang/rust/pull/16367
 
 use run_make_support::{
-    count_regex_matches_in_files_with_extension, cwd, fs_wrapper, has_extension, regex, rustc,
+    count_regex_matches_in_files_with_extension, cwd, fs as rfs, has_extension, regex, rustc,
     shallow_find_files,
 };
 

tests/run-make/silly-file-names/rmake.rs

@@ -11,13 +11,13 @@
 //@ ignore-windows
 // Reason: Windows refuses files with < and > in their names
 
-use run_make_support::{diff, fs_wrapper, run, rustc};
+use run_make_support::{diff, fs as rfs, run, rustc};
 
 fn main() {
-    fs_wrapper::create_file("<leading-lt");
+    rfs::create_file("<leading-lt");
-    fs_wrapper::write("<leading-lt", r#""comes from a file with a name that begins with <""#);
+    rfs::write("<leading-lt", r#""comes from a file with a name that begins with <""#);
-    fs_wrapper::create_file("trailing-gt>");
+    rfs::create_file("trailing-gt>");
-    fs_wrapper::write("trailing-gt>", r#""comes from a file with a name that ends with >""#);
+    rfs::write("trailing-gt>", r#""comes from a file with a name that ends with >""#);
     rustc().input("silly-file-names.rs").output("silly-file-names").run();
     let out = run("silly-file-names").stdout_utf8();
     diff().expected_file("silly-file-names.run.stdout").actual_text("actual-stdout", out).run();

tests/run-make/symlinked-extern/rmake.rs

@@ -11,12 +11,12 @@
 //@ ignore-cross-compile
 //@ needs-symlink
 
-use run_make_support::{create_symlink, cwd, fs_wrapper, rustc};
+use run_make_support::{cwd, fs as rfs, rustc};
 
 fn main() {
     rustc().input("foo.rs").run();
-    fs_wrapper::create_dir_all("other");
+    rfs::create_dir_all("other");
-    create_symlink("libfoo.rlib", "other");
+    rfs::create_symlink("libfoo.rlib", "other");
     rustc().input("bar.rs").library_search_path(cwd()).run();
     rustc().input("baz.rs").extern_("foo", "other").library_search_path(cwd()).run();
 }

tests/run-make/symlinked-libraries/rmake.rs

@@ -8,11 +8,11 @@
 //@ ignore-cross-compile
 //@ needs-symlink
 
-use run_make_support::{create_symlink, dynamic_lib_name, fs_wrapper, rustc};
+use run_make_support::{dynamic_lib_name, fs as rfs, rustc};
 
 fn main() {
     rustc().input("foo.rs").arg("-Cprefer-dynamic").run();
-    fs_wrapper::create_dir_all("other");
+    rfs::create_dir_all("other");
-    create_symlink(dynamic_lib_name("foo"), "other");
+    rfs::create_symlink(dynamic_lib_name("foo"), "other");
     rustc().input("bar.rs").library_search_path("other").run();
 }

tests/run-make/symlinked-rlib/rmake.rs

@@ -8,10 +8,10 @@
 //@ ignore-cross-compile
 //@ needs-symlink
 
-use run_make_support::{create_symlink, cwd, rustc};
+use run_make_support::{cwd, fs as rfs, rustc};
 
 fn main() {
     rustc().input("foo.rs").crate_type("rlib").output("foo.xxx").run();
-    create_symlink("foo.xxx", "libfoo.rlib");
+    rfs::create_symlink("foo.xxx", "libfoo.rlib");
     rustc().input("bar.rs").library_search_path(cwd()).run();
 }

tests/run-make/target-specs/rmake.rs

@@ -5,11 +5,11 @@
 // using them correctly, or fails with the right error message when using them improperly.
 // See https://github.com/rust-lang/rust/pull/16156
 
-use run_make_support::{diff, fs_wrapper, rustc};
+use run_make_support::{diff, fs as rfs, rustc};
 
 fn main() {
     rustc().input("foo.rs").target("my-awesome-platform.json").crate_type("lib").emit("asm").run();
-    assert!(!fs_wrapper::read_to_string("foo.s").contains("morestack"));
+    assert!(!rfs::read_to_string("foo.s").contains("morestack"));
     rustc()
         .input("foo.rs")
         .target("my-invalid-platform.json")
@@ -40,8 +40,8 @@ fn main() {
         .print("target-spec-json")
         .run()
         .stdout_utf8();
-    fs_wrapper::create_file("test-platform.json");
+    rfs::create_file("test-platform.json");
-    fs_wrapper::write("test-platform.json", test_platform.as_bytes());
+    rfs::write("test-platform.json", test_platform.as_bytes());
     let test_platform_2 = rustc()
         .arg("-Zunstable-options")
         .target("test-platform.json")

tests/run-make/track-path-dep-info/rmake.rs

@@ -4,10 +4,10 @@
 // output successfully added the file as a dependency.
 // See https://github.com/rust-lang/rust/pull/84029
 
-use run_make_support::{fs_wrapper, rustc};
+use run_make_support::{fs as rfs, rustc};
 
 fn main() {
     rustc().input("macro_def.rs").run();
     rustc().env("EXISTING_PROC_MACRO_ENV", "1").emit("dep-info").input("macro_use.rs").run();
-    assert!(fs_wrapper::read_to_string("macro_use.d").contains("emojis.txt:"));
+    assert!(rfs::read_to_string("macro_use.d").contains("emojis.txt:"));
 }

tests/run-make/track-pgo-dep-info/rmake.rs

@@ -8,7 +8,7 @@
 // Reason: the binary is executed
 //@ needs-profiler-support
 
-use run_make_support::{fs_wrapper, llvm_profdata, run, rustc};
+use run_make_support::{fs as rfs, llvm_profdata, run, rustc};
 
 fn main() {
     // Generate the profile-guided-optimization (PGO) profiles
@@ -19,5 +19,5 @@ fn main() {
     // Use the profiles in compilation
     rustc().profile_use("merged.profdata").emit("dep-info").input("main.rs").run();
     // Check that the profile file is in the dep-info emit file
-    assert!(fs_wrapper::read_to_string("main.d").contains("merged.profdata"));
+    assert!(rfs::read_to_string("main.d").contains("merged.profdata"));
 }

tests/run-make/volatile-intrinsics/rmake.rs

@@ -1,6 +1,6 @@
 //@ ignore-cross-compile
 
-use run_make_support::fs_wrapper::read;
+use run_make_support::fs as rfs;
 use run_make_support::{assert_contains, run, rustc};
 
 fn main() {
@@ -11,7 +11,7 @@ fn main() {
     // ... and the loads/stores must not be optimized out.
     rustc().input("main.rs").emit("llvm-ir").run();
 
-    let raw_llvm_ir = read("main.ll");
+    let raw_llvm_ir = rfs::read("main.ll");
     let llvm_ir = String::from_utf8_lossy(&raw_llvm_ir);
     assert_contains(&llvm_ir, "load volatile");
     assert_contains(&llvm_ir, "store volatile");

tests/run-make/wasm-custom-section/rmake.rs

@@ -1,13 +1,13 @@
 //@ only-wasm32-wasip1
 
-use run_make_support::{fs_wrapper, rustc, wasmparser};
+use run_make_support::{fs as rfs, rustc, wasmparser};
 use std::collections::HashMap;
 
 fn main() {
     rustc().input("foo.rs").target("wasm32-wasip1").run();
     rustc().input("bar.rs").target("wasm32-wasip1").arg("-Clto").opt().run();
 
-    let file = fs_wrapper::read("bar.wasm");
+    let file = rfs::read("bar.wasm");
 
     let mut custom = HashMap::new();
     for payload in wasmparser::Parser::new(0).parse_all(&file) {

tests/run-make/wasm-custom-sections-opt/rmake.rs

@@ -1,6 +1,6 @@
 //@ only-wasm32-wasip1
 
-use run_make_support::{fs_wrapper, rustc, wasmparser};
+use run_make_support::{fs as rfs, rustc, wasmparser};
 use std::collections::HashMap;
 use std::path::Path;
 
@@ -12,7 +12,7 @@ fn main() {
 
 fn verify(path: &Path) {
     eprintln!("verify {path:?}");
-    let file = fs_wrapper::read(&path);
+    let file = rfs::read(&path);
 
     let mut custom = HashMap::new();
     for payload in wasmparser::Parser::new(0).parse_all(&file) {

tests/run-make/wasm-export-all-symbols/rmake.rs

@@ -1,6 +1,6 @@
 //@ only-wasm32-wasip1
 
-use run_make_support::{fs_wrapper, rustc, wasmparser};
+use run_make_support::{fs as rfs, rustc, wasmparser};
 use std::collections::HashMap;
 use std::path::Path;
 use wasmparser::ExternalKind::*;
@@ -33,7 +33,7 @@ fn test(args: &[&str]) {
 
 fn verify_exports(path: &Path, exports: &[(&str, wasmparser::ExternalKind)]) {
     println!("verify {path:?}");
-    let file = fs_wrapper::read(path);
+    let file = rfs::read(path);
     let mut wasm_exports = HashMap::new();
     for payload in wasmparser::Parser::new(0).parse_all(&file) {
         let payload = payload.unwrap();

tests/run-make/wasm-import-module/rmake.rs

@@ -1,6 +1,6 @@
 //@ only-wasm32-wasip1
 
-use run_make_support::{fs_wrapper, rustc, wasmparser};
+use run_make_support::{fs as rfs, rustc, wasmparser};
 use std::collections::HashMap;
 use wasmparser::TypeRef::Func;
 
@@ -8,7 +8,7 @@ fn main() {
     rustc().input("foo.rs").target("wasm32-wasip1").run();
     rustc().input("bar.rs").target("wasm32-wasip1").arg("-Clto").opt().run();
 
-    let file = fs_wrapper::read("bar.wasm");
+    let file = rfs::read("bar.wasm");
 
     let mut imports = HashMap::new();
     for payload in wasmparser::Parser::new(0).parse_all(&file) {

tests/run-make/wasm-panic-small/rmake.rs

@@ -1,7 +1,7 @@
 //@ only-wasm32-wasip1
 #![deny(warnings)]
 
-use run_make_support::{fs_wrapper, rustc};
+use run_make_support::{fs as rfs, rustc};
 
 fn main() {
     test("a");
@@ -15,7 +15,7 @@ fn test(cfg: &str) {
 
     rustc().input("foo.rs").target("wasm32-wasip1").arg("-Clto").opt().cfg(cfg).run();
 
-    let bytes = fs_wrapper::read("foo.wasm");
+    let bytes = rfs::read("foo.wasm");
     println!("{}", bytes.len());
     assert!(bytes.len() < 40_000);
 }

tests/run-make/wasm-spurious-import/rmake.rs

@@ -1,6 +1,6 @@
 //@ only-wasm32-wasip1
 
-use run_make_support::{fs_wrapper, rustc, wasmparser};
+use run_make_support::{fs as rfs, rustc, wasmparser};
 use std::collections::HashMap;
 
 fn main() {
@@ -13,7 +13,7 @@ fn main() {
         .arg("-Copt-level=z")
         .run();
 
-    let file = fs_wrapper::read("main.wasm");
+    let file = rfs::read("main.wasm");
 
     let mut imports = HashMap::new();
     for payload in wasmparser::Parser::new(0).parse_all(&file) {

tests/run-make/wasm-stringify-ints-small/rmake.rs

@@ -1,12 +1,12 @@
 //@ only-wasm32-wasip1
 #![deny(warnings)]
 
-use run_make_support::{fs_wrapper, rustc};
+use run_make_support::{fs as rfs, rustc};
 
 fn main() {
     rustc().input("foo.rs").target("wasm32-wasip1").arg("-Clto").opt().run();
 
-    let bytes = fs_wrapper::read("foo.wasm");
+    let bytes = rfs::read("foo.wasm");
     println!("{}", bytes.len());
     assert!(bytes.len() < 50_000);
 }

tests/run-make/wasm-symbols-different-module/rmake.rs

@@ -1,6 +1,6 @@
 //@ only-wasm32-wasip1
 
-use run_make_support::{fs_wrapper, rustc, wasmparser};
+use run_make_support::{fs as rfs, rustc, wasmparser};
 use std::collections::{HashMap, HashSet};
 use std::path::Path;
 
@@ -23,7 +23,7 @@ fn test(file: &str, args: &[&str], expected_imports: &[(&str, &[&str])]) {
 
     rustc().input(file).target("wasm32-wasip1").args(args).run();
 
-    let file = fs_wrapper::read(Path::new(file).with_extension("wasm"));
+    let file = rfs::read(Path::new(file).with_extension("wasm"));
 
     let mut imports = HashMap::new();
     for payload in wasmparser::Parser::new(0).parse_all(&file) {

tests/run-make/wasm-symbols-not-exported/rmake.rs

@@ -1,6 +1,6 @@
 //@ only-wasm32-wasip1
 
-use run_make_support::{fs_wrapper, rustc, wasmparser};
+use run_make_support::{fs as rfs, rustc, wasmparser};
 use std::path::Path;
 
 fn main() {
@@ -17,7 +17,7 @@ fn main() {
 
 fn verify_symbols(path: &Path) {
     eprintln!("verify {path:?}");
-    let file = fs_wrapper::read(&path);
+    let file = rfs::read(&path);
 
     for payload in wasmparser::Parser::new(0).parse_all(&file) {
         let payload = payload.unwrap();

tests/run-make/wasm-symbols-not-imported/rmake.rs

@@ -1,6 +1,6 @@
 //@ only-wasm32-wasip1
 
-use run_make_support::{fs_wrapper, rustc, wasmparser};
+use run_make_support::{fs as rfs, rustc, wasmparser};
 use std::path::Path;
 
 fn main() {
@@ -16,7 +16,7 @@ fn main() {
 
 fn verify_symbols(path: &Path) {
     eprintln!("verify {path:?}");
-    let file = fs_wrapper::read(&path);
+    let file = rfs::read(&path);
 
     for payload in wasmparser::Parser::new(0).parse_all(&file) {
         let payload = payload.unwrap();

tests/run-make/weird-output-filenames/rmake.rs

@@ -1,4 +1,4 @@
-use run_make_support::fs_wrapper::copy;
+use run_make_support::fs as rfs;
 use run_make_support::regex::Regex;
 use run_make_support::{cwd, rustc};
 
@@ -6,12 +6,12 @@ fn main() {
     let invalid_characters = [".foo.rs", ".foo.bar", "+foo+bar.rs"];
     let re = Regex::new(r"invalid character.*in crate name:").unwrap();
     for f in invalid_characters {
-        copy("foo.rs", f);
+        rfs::copy("foo.rs", f);
         let stderr = rustc().input(f).run_fail().stderr_utf8();
         assert!(re.is_match(&stderr));
     }
 
-    copy("foo.rs", "-foo.rs");
+    rfs::copy("foo.rs", "-foo.rs");
     rustc()
         .input(cwd().join("-foo.rs"))
         .run_fail()

tests/run-make/windows-ws2_32/rmake.rs

@@ -3,7 +3,7 @@
 // Tests that WS2_32.dll is not unnecessarily linked, see issue #85441
 
 use run_make_support::object::{self, read::Object};
-use run_make_support::{fs_wrapper, rustc};
+use run_make_support::{fs as rfs, rustc};
 
 fn main() {
     rustc().input("empty.rs").run();
@@ -14,7 +14,7 @@ fn main() {
 }
 
 fn links_ws2_32(exe: &str) -> bool {
-    let binary_data = fs_wrapper::read(exe);
+    let binary_data = rfs::read(exe);
     let file = object::File::parse(&*binary_data).unwrap();
     for import in file.imports().unwrap() {
         if import.library().eq_ignore_ascii_case(b"WS2_32.dll") {