replace tmp_dir().join(_) with tmp_path(_)

Author: Oneirical

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

@@ -2,7 +2,9 @@ use std::env;
 use std::path::Path;
 use std::process::Command;
 
-use crate::{bin_name, cygpath_windows, handle_failed_output, is_msvc, is_windows, tmp_dir, uname};
+use crate::{
+    bin_name, cygpath_windows, handle_failed_output, is_msvc, is_windows, tmp_path, uname,
+};
 
 /// Construct a new platform-specific C compiler invocation.
 ///
@@ -68,13 +70,13 @@ impl Cc {
         // ```
 
         if is_msvc() {
-            let fe_path = cygpath_windows(tmp_dir().join(bin_name(name)));
-            let fo_path = cygpath_windows(tmp_dir().join(format!("{name}.obj")));
+            let fe_path = cygpath_windows(tmp_path(bin_name(name)));
+            let fo_path = cygpath_windows(tmp_path(format!("{name}.obj")));
             self.cmd.arg(format!("-Fe:{fe_path}"));
             self.cmd.arg(format!("-Fo:{fo_path}"));
         } else {
             self.cmd.arg("-o");
-            self.cmd.arg(tmp_dir().join(name));
+            self.cmd.arg(tmp_path(name));
         }
 
         self

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

@@ -2,7 +2,7 @@ use std::env;
 use std::path::Path;
 use std::process::Command;
 
-use crate::{bin_name, handle_failed_output, tmp_dir};
+use crate::{bin_name, handle_failed_output, tmp_path};
 
 /// Construct a new `clang` invocation. `clang` is not always available for all targets.
 pub fn clang() -> Clang {
@@ -36,7 +36,7 @@ impl Clang {
     /// extension will be determined by [`bin_name`].
     pub fn out_exe(&mut self, name: &str) -> &mut Self {
         self.cmd.arg("-o");
-        self.cmd.arg(tmp_dir().join(bin_name(name)));
+        self.cmd.arg(tmp_path(bin_name(name)));
         self
     }
 

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

@@ -35,6 +35,10 @@ 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()
@@ -58,7 +62,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_dir().join(static_lib_name(name))
+    tmp_path(static_lib_name(name))
 }
 
 pub fn python_command() -> Command {
@@ -103,7 +107,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_dir().join(dynamic_lib_name(name))
+    tmp_path(dynamic_lib_name(name))
 }
 
 /// Construct the dynamic library name based on the platform.
@@ -135,7 +139,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_dir().join(rust_lib_name(name))
+    tmp_path(rust_lib_name(name))
 }
 
 /// Generate the name a rust library (rlib) would have. If you want the complete path, use

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

@@ -21,7 +21,7 @@ use run_make_support::object::ObjectSection;
 use run_make_support::object::ObjectSymbol;
 use run_make_support::object::RelocationTarget;
 use run_make_support::set_host_rpath;
-use run_make_support::tmp_dir;
+use run_make_support::tmp_path;
 use std::collections::HashSet;
 
 const MANIFEST: &str = r#"
@@ -34,15 +34,15 @@ edition = "2021"
 path = "lib.rs""#;
 
 fn main() {
-    let target_dir = tmp_dir().join("target");
+    let target_dir = tmp_path("target");
     let target = std::env::var("TARGET").unwrap();
 
     println!("Testing compiler_builtins for {}", target);
 
     // Set up the tiniest Cargo project: An empty no_std library. Just enough to run -Zbuild-std.
-    let manifest_path = tmp_dir().join("Cargo.toml");
+    let manifest_path = tmp_path("Cargo.toml");
     std::fs::write(&manifest_path, MANIFEST.as_bytes()).unwrap();
-    std::fs::write(tmp_dir().join("lib.rs"), b"#![no_std]").unwrap();
+    std::fs::write(tmp_path("lib.rs"), b"#![no_std]").unwrap();
 
     let path = std::env::var("PATH").unwrap();
     let rustc = std::env::var("RUSTC").unwrap();

tests/run-make/core-no-oom-handling/rmake.rs

@@ -2,15 +2,15 @@
 // when the no_global_oom_handling feature is turned on.
 // See https://github.com/rust-lang/rust/pull/110649
 
-use run_make_support::{rustc, tmp_dir};
+use run_make_support::{rustc, tmp_path};
 
 fn main() {
     rustc()
         .edition("2021")
         .arg("-Dwarnings")
         .crate_type("rlib")
         .input("../../../library/core/src/lib.rs")
-        .sysroot(tmp_dir().join("fakeroot"))
+        .sysroot(tmp_path("fakeroot"))
         .cfg("no_global_oom_handling")
         .run();
 }

tests/run-make/cross-lang-lto-riscv-abi/rmake.rs

@@ -3,7 +3,7 @@
 //@ needs-matching-clang
 //@ needs-llvm-components riscv
 
-use run_make_support::{bin_name, clang, llvm_readobj, rustc, tmp_dir};
+use run_make_support::{bin_name, clang, llvm_readobj, rustc, tmp_path};
 use std::{
     env,
     path::PathBuf,
@@ -30,11 +30,11 @@ fn check_target(target: &str, clang_target: &str, carch: &str, is_double_float:
         .no_stdlib()
         .out_exe("riscv-xlto")
         .input("cstart.c")
-        .input(tmp_dir().join("libriscv_xlto.rlib"))
+        .input(tmp_path("libriscv_xlto.rlib"))
         .run();
 
     // Check that the built binary has correct float abi
-    let executable = tmp_dir().join(bin_name("riscv-xlto"));
+    let executable = tmp_path(bin_name("riscv-xlto"));
     let output = llvm_readobj().input(&executable).file_header().run();
     let stdout = String::from_utf8_lossy(&output.stdout);
     eprintln!("obj:\n{}", stdout);

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

@@ -1,15 +1,15 @@
 // Check that valid binaries are persisted by running them, regardless of whether the
 // --run or --no-run option is used.
 
-use run_make_support::{run, rustc, rustdoc, tmp_dir};
+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_dir().join("doctests");
+    let out_dir = tmp_path("doctests");
     create_dir(&out_dir).expect("failed to create doctests folder");
     rustc().input("t.rs").crate_type("rlib").run();
-    callback(&out_dir, &tmp_dir().join("libt.rlib"));
+    callback(&out_dir, &tmp_path("libt.rlib"));
     remove_dir_all(out_dir);
 }
 
@@ -45,7 +45,7 @@ fn main() {
     // Behavior with --test-run-directory with relative paths.
     setup_test_env(|_out_dir, extern_path| {
         let run_dir = "rundir";
-        let run_dir_path = tmp_dir().join("rundir");
+        let run_dir_path = tmp_path("rundir");
         create_dir(&run_dir_path).expect("failed to create rundir folder");
 
         rustdoc()

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

@@ -1,12 +1,12 @@
 // Tests behavior of rustdoc `--runtool`.
 
-use run_make_support::{rustc, rustdoc, tmp_dir};
+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_dir().join(name);
+    let dir = tmp_path(name);
     create_dir(&dir).expect("failed to create doctests folder");
     dir
 }

tests/run-make/exit-code/rmake.rs

@@ -1,6 +1,6 @@
 // Test that we exit with the correct exit code for successful / unsuccessful / ICE compilations
 
-use run_make_support::{rustc, rustdoc, tmp_dir};
+use run_make_support::{rustc, rustdoc, tmp_path};
 
 fn main() {
     rustc().arg("success.rs").run();
@@ -15,7 +15,7 @@ fn main() {
         .arg("compile-error.rs")
         .run_fail_assert_exit_code(101);
 
-    rustdoc().arg("success.rs").output(tmp_dir().join("exit-code")).run();
+    rustdoc().arg("success.rs").output(tmp_path("exit-code")).run();
 
     rustdoc().arg("--invalid-arg-foo").run_fail_assert_exit_code(1);
 

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

@@ -3,7 +3,7 @@
 #[cfg(unix)]
 extern crate libc;
 
-use run_make_support::{aux_build, tmp_dir};
+use run_make_support::{aux_build, tmp_path};
 use std::fs;
 #[cfg(unix)]
 use std::os::unix::fs::PermissionsExt;
@@ -16,7 +16,7 @@ fn main() {
     }
 
     aux_build().arg("foo.rs").run();
-    verify(&tmp_dir().join("libfoo.rlib"));
+    verify(&tmp_path("libfoo.rlib"));
 }
 
 fn verify(path: &Path) {